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

Copy as Markdown

Other Tools

//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/PBrowserChild.h"
#include "ipc/nsGUIEventIPC.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/LayoutMessageUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/ProfilerMarkers.h"
#include "mozilla/RemoteLazyInputStream.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/BindingIPCUtils.h"
#include "mozilla/dom/BrowserChild.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/FilePickerMessageUtils.h"
#include "mozilla/dom/MessagePort.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/SessionHistoryEntry.h"
#include "mozilla/dom/SessionStoreMessageUtils.h"
#include "mozilla/dom/TabMessageTypes.h"
#include "mozilla/dom/TabMessageUtils.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"
#include "mozilla/ipc/BigBuffer.h"
#include "mozilla/ipc/IPCCore.h"
#include "mozilla/ipc/IPCStreamUtils.h"
#include "mozilla/ipc/SerializedStructuredCloneBuffer.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/CompositorTypes.h"
#include "mozilla/layers/DoubleTapToZoom.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/layers/ScrollableLayerGuid.h"
#include "mozilla/layers/ZoomConstraints.h"
#include "mozilla/net/CacheInfoIPCTypes.h"
#include "mozilla/net/ClassOfService.h"
#include "mozilla/widget/IMEData.h"
#include "mozilla/widget/WidgetMessageUtils.h"
#include "nsDOMNavigationTiming.h"
#include "nsDocShellLoadState.h"
#include "nsHttp.h"
#include "nsHttpResponseHead.h"
#include "nsIContentSecurityPolicy.h"
#include "nsID.h"
#include "nsIPrincipal.h"
#include "nsIPropertyBag2.h"
#include "nsIReferrerInfo.h"
#include "nsITransportSecurityInfo.h"
#include "nsIURI.h"
#include "nsIVariant.h"
#include "nsRect.h"
#include "mozilla/dom/PColorPickerChild.h"
#include "mozilla/dom/PContentChild.h"
#include "mozilla/a11y/PDocAccessibleChild.h"
#include "mozilla/dom/PFilePickerChild.h"
#include "mozilla/layout/PRemotePrintJobChild.h"
#include "mozilla/dom/PPaymentRequestChild.h"
#include "mozilla/dom/PSessionStoreChild.h"
#include "mozilla/dom/PWindowGlobalChild.h"
#include "mozilla/dom/PBrowserBridgeChild.h"
#include "mozilla/dom/PVsyncChild.h"
#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"
namespace mozilla {
namespace dom {
MOZ_IMPLICIT PBrowserChild::PBrowserChild() :
mozilla::ipc::IRefCountedProtocol(PBrowserMsgStart, mozilla::ipc::ChildSide)
{
MOZ_COUNT_CTOR(PBrowserChild);
}
PBrowserChild::~PBrowserChild()
{
MOZ_COUNT_DTOR(PBrowserChild);
}
auto PBrowserChild::ActorAlloc() -> void
{
AddRef();
}
auto PBrowserChild::ActorDealloc() -> void
{
Release();
}
auto PBrowserChild::OtherPid() const -> ::base::ProcessId
{
::base::ProcessId pid =
::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherPidMaybeInvalid();
MOZ_RELEASE_ASSERT(pid != ::base::kInvalidProcessId);
return pid;
}
auto PBrowserChild::Manager() const -> PContentChild*
{
return static_cast<PContentChild*>(IProtocol::Manager());
}
auto PBrowserChild::ManagedPColorPickerChild(nsTArray<PColorPickerChild*>& aArr) const -> void
{
mManagedPColorPickerChild.ToArray(aArr);
}
auto PBrowserChild::ManagedPColorPickerChild() const -> const ManagedContainer<PColorPickerChild>&
{
return mManagedPColorPickerChild;
}
auto PBrowserChild::ManagedPDocAccessibleChild(nsTArray<PDocAccessibleChild*>& aArr) const -> void
{
mManagedPDocAccessibleChild.ToArray(aArr);
}
auto PBrowserChild::ManagedPDocAccessibleChild() const -> const ManagedContainer<PDocAccessibleChild>&
{
return mManagedPDocAccessibleChild;
}
auto PBrowserChild::ManagedPFilePickerChild(nsTArray<PFilePickerChild*>& aArr) const -> void
{
mManagedPFilePickerChild.ToArray(aArr);
}
auto PBrowserChild::ManagedPFilePickerChild() const -> const ManagedContainer<PFilePickerChild>&
{
return mManagedPFilePickerChild;
}
auto PBrowserChild::ManagedPPaymentRequestChild(nsTArray<PPaymentRequestChild*>& aArr) const -> void
{
mManagedPPaymentRequestChild.ToArray(aArr);
}
auto PBrowserChild::ManagedPPaymentRequestChild() const -> const ManagedContainer<PPaymentRequestChild>&
{
return mManagedPPaymentRequestChild;
}
auto PBrowserChild::ManagedPSessionStoreChild(nsTArray<PSessionStoreChild*>& aArr) const -> void
{
mManagedPSessionStoreChild.ToArray(aArr);
}
auto PBrowserChild::ManagedPSessionStoreChild() const -> const ManagedContainer<PSessionStoreChild>&
{
return mManagedPSessionStoreChild;
}
auto PBrowserChild::ManagedPWindowGlobalChild(nsTArray<PWindowGlobalChild*>& aArr) const -> void
{
mManagedPWindowGlobalChild.ToArray(aArr);
}
auto PBrowserChild::ManagedPWindowGlobalChild() const -> const ManagedContainer<PWindowGlobalChild>&
{
return mManagedPWindowGlobalChild;
}
auto PBrowserChild::ManagedPBrowserBridgeChild(nsTArray<PBrowserBridgeChild*>& aArr) const -> void
{
mManagedPBrowserBridgeChild.ToArray(aArr);
}
auto PBrowserChild::ManagedPBrowserBridgeChild() const -> const ManagedContainer<PBrowserBridgeChild>&
{
return mManagedPBrowserBridgeChild;
}
auto PBrowserChild::ManagedPVsyncChild(nsTArray<PVsyncChild*>& aArr) const -> void
{
mManagedPVsyncChild.ToArray(aArr);
}
auto PBrowserChild::ManagedPVsyncChild() const -> const ManagedContainer<PVsyncChild>&
{
return mManagedPVsyncChild;
}
auto PBrowserChild::AllManagedActorsCount() const -> uint32_t
{
uint32_t total = 0;
total += mManagedPColorPickerChild.Count();
total += mManagedPDocAccessibleChild.Count();
total += mManagedPFilePickerChild.Count();
total += mManagedPPaymentRequestChild.Count();
total += mManagedPSessionStoreChild.Count();
total += mManagedPWindowGlobalChild.Count();
total += mManagedPBrowserBridgeChild.Count();
total += mManagedPVsyncChild.Count();
return total;
}
auto PBrowserChild::OpenPColorPickerEndpoint(PColorPickerChild* aActor) -> ManagedEndpoint<PColorPickerParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PColorPickerChild actor");
return ManagedEndpoint<PColorPickerParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPColorPickerChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PColorPickerChild actor");
return ManagedEndpoint<PColorPickerParent>();
}
// 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<PColorPickerParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserChild::BindPColorPickerEndpoint(
ManagedEndpoint<PColorPickerChild> aEndpoint,
PColorPickerChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPColorPickerChild);
}
auto PBrowserChild::OpenPDocAccessibleEndpoint(PDocAccessibleChild* aActor) -> ManagedEndpoint<PDocAccessibleParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PDocAccessibleChild actor");
return ManagedEndpoint<PDocAccessibleParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPDocAccessibleChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PDocAccessibleChild actor");
return ManagedEndpoint<PDocAccessibleParent>();
}
// 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<PDocAccessibleParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserChild::BindPDocAccessibleEndpoint(
ManagedEndpoint<PDocAccessibleChild> aEndpoint,
PDocAccessibleChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPDocAccessibleChild);
}
auto PBrowserChild::OpenPFilePickerEndpoint(PFilePickerChild* aActor) -> ManagedEndpoint<PFilePickerParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PFilePickerChild actor");
return ManagedEndpoint<PFilePickerParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPFilePickerChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PFilePickerChild actor");
return ManagedEndpoint<PFilePickerParent>();
}
// 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<PFilePickerParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserChild::BindPFilePickerEndpoint(
ManagedEndpoint<PFilePickerChild> aEndpoint,
PFilePickerChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPFilePickerChild);
}
auto PBrowserChild::OpenPPaymentRequestEndpoint(PPaymentRequestChild* aActor) -> ManagedEndpoint<PPaymentRequestParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PPaymentRequestChild actor");
return ManagedEndpoint<PPaymentRequestParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPPaymentRequestChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PPaymentRequestChild actor");
return ManagedEndpoint<PPaymentRequestParent>();
}
// 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<PPaymentRequestParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserChild::BindPPaymentRequestEndpoint(
ManagedEndpoint<PPaymentRequestChild> aEndpoint,
PPaymentRequestChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPPaymentRequestChild);
}
auto PBrowserChild::OpenPSessionStoreEndpoint(PSessionStoreChild* aActor) -> ManagedEndpoint<PSessionStoreParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PSessionStoreChild actor");
return ManagedEndpoint<PSessionStoreParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPSessionStoreChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PSessionStoreChild actor");
return ManagedEndpoint<PSessionStoreParent>();
}
// 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<PSessionStoreParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserChild::BindPSessionStoreEndpoint(
ManagedEndpoint<PSessionStoreChild> aEndpoint,
PSessionStoreChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPSessionStoreChild);
}
auto PBrowserChild::OpenPWindowGlobalEndpoint(PWindowGlobalChild* aActor) -> ManagedEndpoint<PWindowGlobalParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWindowGlobalChild actor");
return ManagedEndpoint<PWindowGlobalParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPWindowGlobalChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PWindowGlobalChild actor");
return ManagedEndpoint<PWindowGlobalParent>();
}
// 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<PWindowGlobalParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserChild::BindPWindowGlobalEndpoint(
ManagedEndpoint<PWindowGlobalChild> aEndpoint,
PWindowGlobalChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPWindowGlobalChild);
}
auto PBrowserChild::OpenPBrowserBridgeEndpoint(PBrowserBridgeChild* aActor) -> ManagedEndpoint<PBrowserBridgeParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBrowserBridgeChild actor");
return ManagedEndpoint<PBrowserBridgeParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPBrowserBridgeChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PBrowserBridgeChild actor");
return ManagedEndpoint<PBrowserBridgeParent>();
}
// 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<PBrowserBridgeParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserChild::BindPBrowserBridgeEndpoint(
ManagedEndpoint<PBrowserBridgeChild> aEndpoint,
PBrowserBridgeChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPBrowserBridgeChild);
}
auto PBrowserChild::OpenPVsyncEndpoint(PVsyncChild* aActor) -> ManagedEndpoint<PVsyncParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PVsyncChild actor");
return ManagedEndpoint<PVsyncParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPVsyncChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PVsyncChild actor");
return ManagedEndpoint<PVsyncParent>();
}
// 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<PVsyncParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserChild::BindPVsyncEndpoint(
ManagedEndpoint<PVsyncChild> aEndpoint,
PVsyncChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPVsyncChild);
}
auto PBrowserChild::SendAsyncMessage(
const nsAString& aMessage,
const ClonedMessageData& aData) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_AsyncMessage(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aMessage);
// Sentinel = 'aMessage'
((&(writer__)))->WriteSentinel(233440039);
IPC::WriteParam((&(writer__)), aData);
// Sentinel = 'aData'
((&(writer__)))->WriteSentinel(90571228);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_AsyncMessage", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendPDocAccessibleConstructor(
PDocAccessibleChild* aParentDoc,
const uint64_t& aParentAcc,
const MaybeDiscardedBrowsingContext& aBrowsingContext) -> PDocAccessibleChild*
{
PDocAccessibleChild* actor = (static_cast<BrowserChild*>(this))->AllocPDocAccessibleChild(aParentDoc, aParentAcc, aBrowsingContext);
return SendPDocAccessibleConstructor(std::move(actor), std::move(aParentDoc), std::move(aParentAcc), std::move(aBrowsingContext));
}
auto PBrowserChild::SendPDocAccessibleConstructor(
PDocAccessibleChild* actor,
PDocAccessibleChild* aParentDoc,
const uint64_t& aParentAcc,
const MaybeDiscardedBrowsingContext& aBrowsingContext) -> PDocAccessibleChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PDocAccessibleChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPDocAccessibleChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PDocAccessibleChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_PDocAccessibleConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), aParentDoc);
// Sentinel = 'aParentDoc'
((&(writer__)))->WriteSentinel(355140578);
IPC::WriteParam((&(writer__)), aParentAcc);
// Sentinel = 'aParentAcc'
((&(writer__)))->WriteSentinel(352977875);
IPC::WriteParam((&(writer__)), aBrowsingContext);
// Sentinel = 'aBrowsingContext'
((&(writer__)))->WriteSentinel(915015314);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PDocAccessibleConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PDocAccessibleChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PBrowserChild::SendPPaymentRequestConstructor() -> PPaymentRequestChild*
{
PPaymentRequestChild* actor = (static_cast<BrowserChild*>(this))->AllocPPaymentRequestChild();
return SendPPaymentRequestConstructor(std::move(actor));
}
auto PBrowserChild::SendPPaymentRequestConstructor(PPaymentRequestChild* actor) -> PPaymentRequestChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PPaymentRequestChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPPaymentRequestChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PPaymentRequestChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_PPaymentRequestConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PPaymentRequestConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PPaymentRequestChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PBrowserChild::SendPVsyncConstructor(PVsyncChild* actor) -> PVsyncChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PVsyncChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPVsyncChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PVsyncChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_PVsyncConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PVsyncConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PVsyncChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PBrowserChild::SendDidUnsuppressPainting() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DidUnsuppressPainting(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DidUnsuppressPainting", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendDidUnsuppressPaintingNormalPriority() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DidUnsuppressPaintingNormalPriority(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DidUnsuppressPaintingNormalPriority", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendMoveFocus(
const bool& forward,
const bool& forDocumentNavigation) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_MoveFocus(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), forward);
// Sentinel = 'forward'
((&(writer__)))->WriteSentinel(200016630);
IPC::WriteParam((&(writer__)), forDocumentNavigation);
// Sentinel = 'forDocumentNavigation'
((&(writer__)))->WriteSentinel(1571555479);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_MoveFocus", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendDropLinks(mozilla::Span<nsString const> aLinks) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DropLinks(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aLinks);
// Sentinel = 'aLinks'
((&(writer__)))->WriteSentinel(134152803);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DropLinks", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendSyncMessage(
const nsAString& aMessage,
const ClonedMessageData& aData,
nsTArray<StructuredCloneData>* retval) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SyncMessage(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aMessage);
// Sentinel = 'aMessage'
((&(writer__)))->WriteSentinel(233440039);
IPC::WriteParam((&(writer__)), aData);
// Sentinel = 'aData'
((&(writer__)))->WriteSentinel(90571228);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SyncMessage", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PBrowser::Msg_SyncMessage", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__retval__reply = IPC::ReadParam<nsTArray<StructuredCloneData>>((&(reader__)));
if (!maybe__retval__reply) {
FatalError("Error deserializing 'StructuredCloneData[]'");
return false;
}
auto& retval__reply = *maybe__retval__reply;
// Sentinel = 'retval'
if ((!(((&(reader__)))->ReadSentinel(151716495)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'StructuredCloneData[]'");
return false;
}
(*(retval)) = std::move(retval__reply);
reader__.EndRead();
return true;
}
auto PBrowserChild::SendNotifyIMEFocus(
const ContentCache& contentCache,
const IMENotification& notification,
mozilla::ipc::ResolveCallback<IMENotificationRequests>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NotifyIMEFocus(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), contentCache);
// Sentinel = 'contentCache'
((&(writer__)))->WriteSentinel(535299280);
IPC::WriteParam((&(writer__)), notification);
// Sentinel = 'notification'
((&(writer__)))->WriteSentinel(550438152);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMEFocus", OTHER);
ChannelSend(std::move(msg__), PBrowser::Reply_NotifyIMEFocus__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PBrowserChild::SendNotifyIMEFocus(
const ContentCache& contentCache,
const IMENotification& notification) -> RefPtr<NotifyIMEFocusPromise>
{
RefPtr<MozPromise<IMENotificationRequests, ResponseRejectReason, true>::Private> promise__ = new MozPromise<IMENotificationRequests, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendNotifyIMEFocus(std::move(contentCache), std::move(notification), [promise__](IMENotificationRequests&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PBrowserChild::SendNotifyIMETextChange(
const ContentCache& contentCache,
const IMENotification& notification) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NotifyIMETextChange(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), contentCache);
// Sentinel = 'contentCache'
((&(writer__)))->WriteSentinel(535299280);
IPC::WriteParam((&(writer__)), notification);
// Sentinel = 'notification'
((&(writer__)))->WriteSentinel(550438152);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMETextChange", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendNotifyIMECompositionUpdate(
const ContentCache& contentCache,
const IMENotification& notification) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NotifyIMECompositionUpdate(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), contentCache);
// Sentinel = 'contentCache'
((&(writer__)))->WriteSentinel(535299280);
IPC::WriteParam((&(writer__)), notification);
// Sentinel = 'notification'
((&(writer__)))->WriteSentinel(550438152);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMECompositionUpdate", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendNotifyIMESelection(
const ContentCache& contentCache,
const IMENotification& notification) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NotifyIMESelection(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), contentCache);
// Sentinel = 'contentCache'
((&(writer__)))->WriteSentinel(535299280);
IPC::WriteParam((&(writer__)), notification);
// Sentinel = 'notification'
((&(writer__)))->WriteSentinel(550438152);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMESelection", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendUpdateContentCache(const ContentCache& contentCache) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateContentCache(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), contentCache);
// Sentinel = 'contentCache'
((&(writer__)))->WriteSentinel(535299280);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateContentCache", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendNotifyIMEMouseButtonEvent(
const IMENotification& notification,
bool* consumedByIME) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NotifyIMEMouseButtonEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), notification);
// Sentinel = 'notification'
((&(writer__)))->WriteSentinel(550438152);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMEMouseButtonEvent", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PBrowser::Msg_NotifyIMEMouseButtonEvent", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__consumedByIME__reply = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__consumedByIME__reply) {
FatalError("Error deserializing 'bool'");
return false;
}
auto& consumedByIME__reply = *maybe__consumedByIME__reply;
// Sentinel = 'consumedByIME'
if ((!(((&(reader__)))->ReadSentinel(621282549)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return false;
}
(*(consumedByIME)) = std::move(consumedByIME__reply);
reader__.EndRead();
return true;
}
auto PBrowserChild::SendNotifyIMEPositionChange(
const ContentCache& contentCache,
const IMENotification& notification) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NotifyIMEPositionChange(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), contentCache);
// Sentinel = 'contentCache'
((&(writer__)))->WriteSentinel(535299280);
IPC::WriteParam((&(writer__)), notification);
// Sentinel = 'notification'
((&(writer__)))->WriteSentinel(550438152);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMEPositionChange", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendRequestIMEToCommitComposition(
const bool& cancel,
const uint32_t& aCompositionId,
bool* isCommitted,
nsString* committedString) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RequestIMEToCommitComposition(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), cancel);
// Sentinel = 'cancel'
((&(writer__)))->WriteSentinel(139723367);
IPC::WriteParam((&(writer__)), aCompositionId);
// Sentinel = 'aCompositionId'
((&(writer__)))->WriteSentinel(707069347);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RequestIMEToCommitComposition", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PBrowser::Msg_RequestIMEToCommitComposition", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__isCommitted__reply = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__isCommitted__reply) {
FatalError("Error deserializing 'bool'");
return false;
}
auto& isCommitted__reply = *maybe__isCommitted__reply;
// Sentinel = 'isCommitted'
if ((!(((&(reader__)))->ReadSentinel(449774723)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return false;
}
auto maybe__committedString__reply = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__committedString__reply) {
FatalError("Error deserializing 'nsString'");
return false;
}
auto& committedString__reply = *maybe__committedString__reply;
// Sentinel = 'committedString'
if ((!(((&(reader__)))->ReadSentinel(840042046)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return false;
}
(*(isCommitted)) = std::move(isCommitted__reply);
(*(committedString)) = std::move(committedString__reply);
reader__.EndRead();
return true;
}
auto PBrowserChild::SendOnEventNeedingAckHandled(
const EventMessage& message,
const uint32_t& compositionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_OnEventNeedingAckHandled(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), message);
// Sentinel = 'message'
((&(writer__)))->WriteSentinel(197198566);
IPC::WriteParam((&(writer__)), compositionId);
// Sentinel = 'compositionId'
((&(writer__)))->WriteSentinel(645268834);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_OnEventNeedingAckHandled", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendRequestFocus(
const bool& canRaise,
const CallerType& aCallerType) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RequestFocus(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), canRaise);
// Sentinel = 'canRaise'
((&(writer__)))->WriteSentinel(234816295);
IPC::WriteParam((&(writer__)), aCallerType);
// Sentinel = 'aCallerType'
((&(writer__)))->WriteSentinel(422118487);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RequestFocus", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendWheelZoomChange(const bool& increase) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_WheelZoomChange(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), increase);
// Sentinel = 'increase'
((&(writer__)))->WriteSentinel(249561931);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_WheelZoomChange", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendEnableDisableCommands(
const MaybeDiscardedBrowsingContext& bc,
const nsAString& action,
mozilla::Span<nsCString const> enabledCommands,
mozilla::Span<nsCString const> disabledCommands) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_EnableDisableCommands(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), bc);
// Sentinel = 'bc'
((&(writer__)))->WriteSentinel(19464390);
IPC::WriteParam((&(writer__)), action);
// Sentinel = 'action'
((&(writer__)))->WriteSentinel(143786623);
IPC::WriteParam((&(writer__)), enabledCommands);
// Sentinel = 'enabledCommands'
((&(writer__)))->WriteSentinel(796263934);
IPC::WriteParam((&(writer__)), disabledCommands);
// Sentinel = 'disabledCommands'
((&(writer__)))->WriteSentinel(909706859);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_EnableDisableCommands", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendGetInputContext(IMEState* state) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_GetInputContext(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_GetInputContext", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PBrowser::Msg_GetInputContext", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__state__reply = IPC::ReadParam<IMEState>((&(reader__)));
if (!maybe__state__reply) {
FatalError("Error deserializing 'IMEState'");
return false;
}
auto& state__reply = *maybe__state__reply;
// Sentinel = 'state'
if ((!(((&(reader__)))->ReadSentinel(109314594)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IMEState'");
return false;
}
(*(state)) = std::move(state__reply);
reader__.EndRead();
return true;
}
auto PBrowserChild::SendSetInputContext(
const InputContext& context,
const InputContextAction& action) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SetInputContext(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), context);
// Sentinel = 'context'
((&(writer__)))->WriteSentinel(199164678);
IPC::WriteParam((&(writer__)), action);
// Sentinel = 'action'
((&(writer__)))->WriteSentinel(143786623);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SetInputContext", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendSetCursor(
const nsCursor& value,
mozilla::Maybe<IPCImage>&& customCursor,
const float& resolutionX,
const float& resolutionY,
const uint32_t& hotspotX,
const uint32_t& hotspotY,
const bool& force) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SetCursor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), value);
// Sentinel = 'value'
((&(writer__)))->WriteSentinel(107610654);
IPC::WriteParam((&(writer__)), std::move(customCursor));
// Sentinel = 'customCursor'
((&(writer__)))->WriteSentinel(554173722);
IPC::WriteParam((&(writer__)), resolutionX);
// Sentinel = 'resolutionX'
((&(writer__)))->WriteSentinel(478217389);
IPC::WriteParam((&(writer__)), resolutionY);
// Sentinel = 'resolutionY'
((&(writer__)))->WriteSentinel(478282926);
IPC::WriteParam((&(writer__)), hotspotX);
// Sentinel = 'hotspotX'
((&(writer__)))->WriteSentinel(261423978);
IPC::WriteParam((&(writer__)), hotspotY);
// Sentinel = 'hotspotY'
((&(writer__)))->WriteSentinel(261489515);
IPC::WriteParam((&(writer__)), force);
// Sentinel = 'force'
((&(writer__)))->WriteSentinel(104858128);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SetCursor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendSetLinkStatus(const nsAString& status) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SetLinkStatus(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), status);
// Sentinel = 'status'
((&(writer__)))->WriteSentinel(154731173);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SetLinkStatus", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendShowTooltip(
const uint32_t& x,
const uint32_t& y,
const nsAString& tooltip,
const nsAString& direction) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ShowTooltip(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), x);
// Sentinel = 'x'
((&(writer__)))->WriteSentinel(7929977);
IPC::WriteParam((&(writer__)), y);
// Sentinel = 'y'
((&(writer__)))->WriteSentinel(7995514);
IPC::WriteParam((&(writer__)), tooltip);
// Sentinel = 'tooltip'
((&(writer__)))->WriteSentinel(205914892);
IPC::WriteParam((&(writer__)), direction);
// Sentinel = 'direction'
((&(writer__)))->WriteSentinel(311886786);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ShowTooltip", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendHideTooltip() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_HideTooltip(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_HideTooltip", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendPColorPickerConstructor(
PColorPickerChild* actor,
const nsAString& title,
const nsAString& initialColor,
mozilla::Span<nsString const> defaultColors) -> PColorPickerChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PColorPickerChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPColorPickerChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PColorPickerChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_PColorPickerConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), title);
// Sentinel = 'title'
((&(writer__)))->WriteSentinel(109445667);
IPC::WriteParam((&(writer__)), initialColor);
// Sentinel = 'initialColor'
((&(writer__)))->WriteSentinel(536216810);
IPC::WriteParam((&(writer__)), defaultColors);
// Sentinel = 'defaultColors'
((&(writer__)))->WriteSentinel(616760664);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PColorPickerConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PColorPickerChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PBrowserChild::SendPFilePickerConstructor(
PFilePickerChild* actor,
const nsAString& aTitle,
const Mode& aMode,
const MaybeDiscardedBrowsingContext& aBrowsingContext) -> PFilePickerChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PFilePickerChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPFilePickerChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PFilePickerChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_PFilePickerConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), aTitle);
// Sentinel = 'aTitle'
((&(writer__)))->WriteSentinel(137167460);
IPC::WriteParam((&(writer__)), aMode);
// Sentinel = 'aMode'
((&(writer__)))->WriteSentinel(93848039);
IPC::WriteParam((&(writer__)), aBrowsingContext);
// Sentinel = 'aBrowsingContext'
((&(writer__)))->WriteSentinel(915015314);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PFilePickerConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PFilePickerChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PBrowserChild::SendRespondStartSwipeEvent(
const uint64_t& aInputBlockId,
const bool& aStartSwipe) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RespondStartSwipeEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
IPC::WriteParam((&(writer__)), aStartSwipe);
// Sentinel = 'aStartSwipe'
((&(writer__)))->WriteSentinel(442565752);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RespondStartSwipeEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendLookUpDictionary(
const nsAString& aText,
mozilla::Span<FontRange const> aFontRangeArray,
const bool& aIsVertical,
const LayoutDeviceIntPoint& aPoint) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_LookUpDictionary(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aText);
// Sentinel = 'aText'
((&(writer__)))->WriteSentinel(97321479);
IPC::WriteParam((&(writer__)), aFontRangeArray);
// Sentinel = 'aFontRangeArray'
((&(writer__)))->WriteSentinel(775095781);
IPC::WriteParam((&(writer__)), aIsVertical);
// Sentinel = 'aIsVertical'
((&(writer__)))->WriteSentinel(427361368);
IPC::WriteParam((&(writer__)), aPoint);
// Sentinel = 'aPoint'
((&(writer__)))->WriteSentinel(136512108);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_LookUpDictionary", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::Send__delete__(PBrowserChild* actor) -> bool
{
if (!actor || !actor->CanSend()) {
NS_WARNING("Attempt to __delete__ missing or closed actor");
return false;
}
UniquePtr<IPC::Message> msg__ = PBrowser::Msg___delete__((actor)->Id());
IPC::MessageWriter writer__{
(*(msg__)),
actor};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
actor->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg___delete__", OTHER);
bool sendok__ = (actor)->ChannelSend(std::move(msg__));
actor->ActorDisconnected(Deletion);
return sendok__;
}
auto PBrowserChild::SendReplyKeyEvent(
const WidgetKeyboardEvent& aEvent,
const nsID& aUUID) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ReplyKeyEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEvent);
// Sentinel = 'aEvent'
((&(writer__)))->WriteSentinel(133956196);
IPC::WriteParam((&(writer__)), aUUID);
// Sentinel = 'aUUID'
((&(writer__)))->WriteSentinel(85131673);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ReplyKeyEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendRequestNativeKeyBindings(
const uint32_t& aType,
const WidgetKeyboardEvent& aEvent,
nsTArray<CommandInt>* commands) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RequestNativeKeyBindings(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aType);
// Sentinel = 'aType'
((&(writer__)))->WriteSentinel(99222020);
IPC::WriteParam((&(writer__)), aEvent);
// Sentinel = 'aEvent'
((&(writer__)))->WriteSentinel(133956196);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RequestNativeKeyBindings", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PBrowser::Msg_RequestNativeKeyBindings", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__commands__reply = IPC::ReadParam<nsTArray<CommandInt>>((&(reader__)));
if (!maybe__commands__reply) {
FatalError("Error deserializing 'CommandInt[]'");
return false;
}
auto& commands__reply = *maybe__commands__reply;
// Sentinel = 'commands'
if ((!(((&(reader__)))->ReadSentinel(249627475)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CommandInt[]'");
return false;
}
(*(commands)) = std::move(commands__reply);
reader__.EndRead();
return true;
}
auto PBrowserChild::SendSynthesizeNativeKeyEvent(
const int32_t& aNativeKeyboardLayout,
const int32_t& aNativeKeyCode,
const uint32_t& aModifierFlags,
const nsAString& aCharacters,
const nsAString& aUnmodifiedCharacters,
const uint64_t& aObserverId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeKeyEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aNativeKeyboardLayout);
// Sentinel = 'aNativeKeyboardLayout'
((&(writer__)))->WriteSentinel(1529153656);
IPC::WriteParam((&(writer__)), aNativeKeyCode);
// Sentinel = 'aNativeKeyCode'
((&(writer__)))->WriteSentinel(680527213);
IPC::WriteParam((&(writer__)), aModifierFlags);
// Sentinel = 'aModifierFlags'
((&(writer__)))->WriteSentinel(681444734);
IPC::WriteParam((&(writer__)), aCharacters);
// Sentinel = 'aCharacters'
((&(writer__)))->WriteSentinel(422380642);
IPC::WriteParam((&(writer__)), aUnmodifiedCharacters);
// Sentinel = 'aUnmodifiedCharacters'
((&(writer__)))->WriteSentinel(1529874534);
IPC::WriteParam((&(writer__)), aObserverId);
// Sentinel = 'aObserverId'
((&(writer__)))->WriteSentinel(435356759);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeKeyEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendSynthesizeNativeMouseEvent(
const LayoutDeviceIntPoint& aPoint,
const uint32_t& aNativeMessage,
const int16_t& aButton,
const uint32_t& aModifierFlags,
const uint64_t& aObserverId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeMouseEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPoint);
// Sentinel = 'aPoint'
((&(writer__)))->WriteSentinel(136512108);
IPC::WriteParam((&(writer__)), aNativeMessage);
// Sentinel = 'aNativeMessage'
((&(writer__)))->WriteSentinel(689702286);
IPC::WriteParam((&(writer__)), aButton);
// Sentinel = 'aButton'
((&(writer__)))->WriteSentinel(184222430);
IPC::WriteParam((&(writer__)), aModifierFlags);
// Sentinel = 'aModifierFlags'
((&(writer__)))->WriteSentinel(681444734);
IPC::WriteParam((&(writer__)), aObserverId);
// Sentinel = 'aObserverId'
((&(writer__)))->WriteSentinel(435356759);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeMouseEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendSynthesizeNativeMouseMove(
const LayoutDeviceIntPoint& aPoint,
const uint64_t& aObserverId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeMouseMove(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPoint);
// Sentinel = 'aPoint'
((&(writer__)))->WriteSentinel(136512108);
IPC::WriteParam((&(writer__)), aObserverId);
// Sentinel = 'aObserverId'
((&(writer__)))->WriteSentinel(435356759);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeMouseMove", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendSynthesizeNativeMouseScrollEvent(
const LayoutDeviceIntPoint& aPoint,
const uint32_t& aNativeMessage,
const double& aDeltaX,
const double& aDeltaY,
const double& aDeltaZ,
const uint32_t& aModifierFlags,
const uint32_t& aAdditionalFlags,
const uint64_t& aObserverId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeMouseScrollEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPoint);
// Sentinel = 'aPoint'
((&(writer__)))->WriteSentinel(136512108);
IPC::WriteParam((&(writer__)), aNativeMessage);
// Sentinel = 'aNativeMessage'
((&(writer__)))->WriteSentinel(689702286);
IPC::WriteParam((&(writer__)), aDeltaX);
// Sentinel = 'aDeltaX'
((&(writer__)))->WriteSentinel(174391972);
IPC::WriteParam((&(writer__)), aDeltaY);
// Sentinel = 'aDeltaY'
((&(writer__)))->WriteSentinel(174457509);
IPC::WriteParam((&(writer__)), aDeltaZ);
// Sentinel = 'aDeltaZ'
((&(writer__)))->WriteSentinel(174523046);
IPC::WriteParam((&(writer__)), aModifierFlags);
// Sentinel = 'aModifierFlags'
((&(writer__)))->WriteSentinel(681444734);
IPC::WriteParam((&(writer__)), aAdditionalFlags);
// Sentinel = 'aAdditionalFlags'
((&(writer__)))->WriteSentinel(880084552);
IPC::WriteParam((&(writer__)), aObserverId);
// Sentinel = 'aObserverId'
((&(writer__)))->WriteSentinel(435356759);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeMouseScrollEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendSynthesizeNativeTouchPoint(
const uint32_t& aPointerId,
const TouchPointerState& aPointerState,
const LayoutDeviceIntPoint& aPoint,
const double& aPointerPressure,
const uint32_t& aPointerOrientation,
const uint64_t& aObserverId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeTouchPoint(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPointerId);
// Sentinel = 'aPointerId'
((&(writer__)))->WriteSentinel(364053488);
IPC::WriteParam((&(writer__)), aPointerState);
// Sentinel = 'aPointerState'
((&(writer__)))->WriteSentinel(610600260);
IPC::WriteParam((&(writer__)), aPoint);
// Sentinel = 'aPoint'
((&(writer__)))->WriteSentinel(136512108);
IPC::WriteParam((&(writer__)), aPointerPressure);
// Sentinel = 'aPointerPressure'
((&(writer__)))->WriteSentinel(922617500);
IPC::WriteParam((&(writer__)), aPointerOrientation);
// Sentinel = 'aPointerOrientation'
((&(writer__)))->WriteSentinel(1287653327);
IPC::WriteParam((&(writer__)), aObserverId);
// Sentinel = 'aObserverId'
((&(writer__)))->WriteSentinel(435356759);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchPoint", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendSynthesizeNativeTouchPadPinch(
const TouchpadGesturePhase& aEventPhase,
const float& aScale,
const LayoutDeviceIntPoint& aPoint,
const int32_t& aModifierFlags) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeTouchPadPinch(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEventPhase);
// Sentinel = 'aEventPhase'
((&(writer__)))->WriteSentinel(428737621);
IPC::WriteParam((&(writer__)), aScale);
// Sentinel = 'aScale'
((&(writer__)))->WriteSentinel(131531338);
IPC::WriteParam((&(writer__)), aPoint);
// Sentinel = 'aPoint'
((&(writer__)))->WriteSentinel(136512108);
IPC::WriteParam((&(writer__)), aModifierFlags);
// Sentinel = 'aModifierFlags'
((&(writer__)))->WriteSentinel(681444734);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchPadPinch", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendSynthesizeNativeTouchTap(
const LayoutDeviceIntPoint& aPoint,
const bool& aLongTap,
const uint64_t& aObserverId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeTouchTap(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPoint);
// Sentinel = 'aPoint'
((&(writer__)))->WriteSentinel(136512108);
IPC::WriteParam((&(writer__)), aLongTap);
// Sentinel = 'aLongTap'
((&(writer__)))->WriteSentinel(229507863);
IPC::WriteParam((&(writer__)), aObserverId);
// Sentinel = 'aObserverId'
((&(writer__)))->WriteSentinel(435356759);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchTap", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendClearNativeTouchSequence(const uint64_t& aObserverId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ClearNativeTouchSequence(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aObserverId);
// Sentinel = 'aObserverId'
((&(writer__)))->WriteSentinel(435356759);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ClearNativeTouchSequence", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendSynthesizeNativePenInput(
const uint32_t& aPointerId,
const TouchPointerState& aPointerState,
const LayoutDeviceIntPoint& aPoint,
const double& aPressure,
const uint32_t& aRotation,
const int32_t& aTiltX,
const int32_t& aTiltY,
const int32_t& aButton,
const uint64_t& aObserverId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativePenInput(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPointerId);
// Sentinel = 'aPointerId'
((&(writer__)))->WriteSentinel(364053488);
IPC::WriteParam((&(writer__)), aPointerState);
// Sentinel = 'aPointerState'
((&(writer__)))->WriteSentinel(610600260);
IPC::WriteParam((&(writer__)), aPoint);
// Sentinel = 'aPoint'
((&(writer__)))->WriteSentinel(136512108);
IPC::WriteParam((&(writer__)), aPressure);
// Sentinel = 'aPressure'
((&(writer__)))->WriteSentinel(304153531);
IPC::WriteParam((&(writer__)), aRotation);
// Sentinel = 'aRotation'
((&(writer__)))->WriteSentinel(301925298);
IPC::WriteParam((&(writer__)), aTiltX);
// Sentinel = 'aTiltX'
((&(writer__)))->WriteSentinel(135791191);
IPC::WriteParam((&(writer__)), aTiltY);
// Sentinel = 'aTiltY'
((&(writer__)))->WriteSentinel(135856728);
IPC::WriteParam((&(writer__)), aButton);
// Sentinel = 'aButton'
((&(writer__)))->WriteSentinel(184222430);
IPC::WriteParam((&(writer__)), aObserverId);
// Sentinel = 'aObserverId'
((&(writer__)))->WriteSentinel(435356759);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativePenInput", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendSynthesizeNativeTouchpadDoubleTap(
const LayoutDeviceIntPoint& aPoint,
const uint32_t& aModifierFlags) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeTouchpadDoubleTap(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPoint);
// Sentinel = 'aPoint'
((&(writer__)))->WriteSentinel(136512108);
IPC::WriteParam((&(writer__)), aModifierFlags);
// Sentinel = 'aModifierFlags'
((&(writer__)))->WriteSentinel(681444734);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchpadDoubleTap", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendSynthesizeNativeTouchpadPan(
const TouchpadGesturePhase& aEventPhase,
const LayoutDeviceIntPoint& aPoint,
const double& aDeltaX,
const double& aDeltaY,
const int32_t& aModifierFlags,
const uint64_t& aObserverId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeTouchpadPan(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEventPhase);
// Sentinel = 'aEventPhase'
((&(writer__)))->WriteSentinel(428737621);
IPC::WriteParam((&(writer__)), aPoint);
// Sentinel = 'aPoint'
((&(writer__)))->WriteSentinel(136512108);
IPC::WriteParam((&(writer__)), aDeltaX);
// Sentinel = 'aDeltaX'
((&(writer__)))->WriteSentinel(174391972);
IPC::WriteParam((&(writer__)), aDeltaY);
// Sentinel = 'aDeltaY'
((&(writer__)))->WriteSentinel(174457509);
IPC::WriteParam((&(writer__)), aModifierFlags);
// Sentinel = 'aModifierFlags'
((&(writer__)))->WriteSentinel(681444734);
IPC::WriteParam((&(writer__)), aObserverId);
// Sentinel = 'aObserverId'
((&(writer__)))->WriteSentinel(435356759);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchpadPan", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendLockNativePointer() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_LockNativePointer(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_LockNativePointer", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendUnlockNativePointer() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UnlockNativePointer(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UnlockNativePointer", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendAccessKeyNotHandled(const WidgetKeyboardEvent& event) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_AccessKeyNotHandled(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_AccessKeyNotHandled", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendRegisterProtocolHandler(
const nsAString& scheme,
nsIURI* handlerURI,
const nsAString& title,
nsIURI* documentURI) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RegisterProtocolHandler(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), scheme);
// Sentinel = 'scheme'
((&(writer__)))->WriteSentinel(146080374);
IPC::WriteParam((&(writer__)), handlerURI);
// Sentinel = 'handlerURI'
((&(writer__)))->WriteSentinel(367264719);
IPC::WriteParam((&(writer__)), title);
// Sentinel = 'title'
((&(writer__)))->WriteSentinel(109445667);
IPC::WriteParam((&(writer__)), documentURI);
// Sentinel = 'documentURI'
((&(writer__)))->WriteSentinel(453706832);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RegisterProtocolHandler", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendOnStateChange(
const WebProgressData& aWebProgressData,
const RequestData& aRequestData,
const uint32_t& aStateFlags,
const nsresult& aStatus,
const mozilla::Maybe<WebProgressStateChangeData>& aStateChangeData) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_OnStateChange(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aWebProgressData);
// Sentinel = 'aWebProgressData'
((&(writer__)))->WriteSentinel(890504783);
IPC::WriteParam((&(writer__)), aRequestData);
// Sentinel = 'aRequestData'
((&(writer__)))->WriteSentinel(518390981);
IPC::WriteParam((&(writer__)), aStateFlags);
// Sentinel = 'aStateFlags'
((&(writer__)))->WriteSentinel(428606544);
IPC::WriteParam((&(writer__)), aStatus);
// Sentinel = 'aStatus'
((&(writer__)))->WriteSentinel(186712806);
IPC::WriteParam((&(writer__)), aStateChangeData);
// Sentinel = 'aStateChangeData'
((&(writer__)))->WriteSentinel(876086819);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_OnStateChange", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendOnLocationChange(
const WebProgressData& aWebProgressData,
const RequestData& aRequestData,
nsIURI* aLocation,
const uint32_t& aFlags,
const bool& aCanGoBack,
const bool& aCanGoForward,
const mozilla::Maybe<WebProgressLocationChangeData>& aLocationChangeData) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_OnLocationChange(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aWebProgressData);
// Sentinel = 'aWebProgressData'
((&(writer__)))->WriteSentinel(890504783);
IPC::WriteParam((&(writer__)), aRequestData);
// Sentinel = 'aRequestData'
((&(writer__)))->WriteSentinel(518390981);
IPC::WriteParam((&(writer__)), aLocation);
// Sentinel = 'aLocation'
((&(writer__)))->WriteSentinel(292094875);
IPC::WriteParam((&(writer__)), aFlags);
// Sentinel = 'aFlags'
((&(writer__)))->WriteSentinel(129892943);
IPC::WriteParam((&(writer__)), aCanGoBack);
// Sentinel = 'aCanGoBack'
((&(writer__)))->WriteSentinel(325714843);
IPC::WriteParam((&(writer__)), aCanGoForward);
// Sentinel = 'aCanGoForward'
((&(writer__)))->WriteSentinel(563152127);
IPC::WriteParam((&(writer__)), aLocationChangeData);
// Sentinel = 'aLocationChangeData'
((&(writer__)))->WriteSentinel(1235617627);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_OnLocationChange", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendOnProgressChange(
const int32_t& aCurTotalProgress,
const int32_t& aMaxTotalProgress) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_OnProgressChange(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aCurTotalProgress);
// Sentinel = 'aCurTotalProgress'
((&(writer__)))->WriteSentinel(1012795109);
IPC::WriteParam((&(writer__)), aMaxTotalProgress);
// Sentinel = 'aMaxTotalProgress'
((&(writer__)))->WriteSentinel(1009125089);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_OnProgressChange", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendOnStatusChange(const nsAString& aMessage) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_OnStatusChange(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aMessage);
// Sentinel = 'aMessage'
((&(writer__)))->WriteSentinel(233440039);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_OnStatusChange", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendNotifyContentBlockingEvent(
const uint32_t& aEvent,
const RequestData& aRequestData,
const bool& aBlocked,
const nsACString& aTrackingOrigin,
mozilla::Span<nsCString const> aTrackingFullHashes,
const mozilla::Maybe<StorageAccessPermissionGrantedReason>& aReason,
const mozilla::Maybe<CanvasFingerprinter>& aCanvasFingerprinter,
const mozilla::Maybe<bool>& aCanvasFingerprinterKnownText) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NotifyContentBlockingEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEvent);
// Sentinel = 'aEvent'
((&(writer__)))->WriteSentinel(133956196);
IPC::WriteParam((&(writer__)), aRequestData);
// Sentinel = 'aRequestData'
((&(writer__)))->WriteSentinel(518390981);
IPC::WriteParam((&(writer__)), aBlocked);
// Sentinel = 'aBlocked'
((&(writer__)))->WriteSentinel(227279638);
IPC::WriteParam((&(writer__)), aTrackingOrigin);
// Sentinel = 'aTrackingOrigin'
((&(writer__)))->WriteSentinel(792331773);
IPC::WriteParam((&(writer__)), aTrackingFullHashes);
// Sentinel = 'aTrackingFullHashes'
((&(writer__)))->WriteSentinel(1248069508);
IPC::WriteParam((&(writer__)), aReason);
// Sentinel = 'aReason'
((&(writer__)))->WriteSentinel(180093642);
IPC::WriteParam((&(writer__)), aCanvasFingerprinter);
// Sentinel = 'aCanvasFingerprinter'
((&(writer__)))->WriteSentinel(1384777757);
IPC::WriteParam((&(writer__)), aCanvasFingerprinterKnownText);
// Sentinel = 'aCanvasFingerprinterKnownText'
((&(writer__)))->WriteSentinel(2910718927);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyContentBlockingEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendNavigationFinished() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NavigationFinished(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NavigationFinished", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendIntrinsicSizeOrRatioChanged(
const mozilla::Maybe<IntrinsicSize>& aIntrinsicSize,
const mozilla::Maybe<AspectRatio>& aIntrinsicRatio) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_IntrinsicSizeOrRatioChanged(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aIntrinsicSize);
// Sentinel = 'aIntrinsicSize'
((&(writer__)))->WriteSentinel(708052400);
IPC::WriteParam((&(writer__)), aIntrinsicRatio);
// Sentinel = 'aIntrinsicRatio'
((&(writer__)))->WriteSentinel(807667220);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_IntrinsicSizeOrRatioChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendImageLoadComplete(const nsresult& aResult) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ImageLoadComplete(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aResult);
// Sentinel = 'aResult'
((&(writer__)))->WriteSentinel(185205473);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ImageLoadComplete", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendRequestPointerLock(
mozilla::ipc::ResolveCallback<nsCString>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RequestPointerLock(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RequestPointerLock", OTHER);
ChannelSend(std::move(msg__), PBrowser::Reply_RequestPointerLock__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PBrowserChild::SendRequestPointerLock() -> RefPtr<RequestPointerLockPromise>
{
RefPtr<MozPromise<nsCString, ResponseRejectReason, true>::Private> promise__ = new MozPromise<nsCString, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendRequestPointerLock([promise__](nsCString&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PBrowserChild::SendReleasePointerLock() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ReleasePointerLock(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ReleasePointerLock", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendRequestPointerCapture(
const uint32_t& aPointerId,
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RequestPointerCapture(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPointerId);
// Sentinel = 'aPointerId'
((&(writer__)))->WriteSentinel(364053488);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RequestPointerCapture", OTHER);
ChannelSend(std::move(msg__), PBrowser::Reply_RequestPointerCapture__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PBrowserChild::SendRequestPointerCapture(const uint32_t& aPointerId) -> RefPtr<RequestPointerCapturePromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendRequestPointerCapture(std::move(aPointerId), [promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PBrowserChild::SendReleasePointerCapture(const uint32_t& aPointerId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ReleasePointerCapture(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPointerId);
// Sentinel = 'aPointerId'
((&(writer__)))->WriteSentinel(364053488);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ReleasePointerCapture", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendRemoteIsReadyToHandleInputEvents() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RemoteIsReadyToHandleInputEvents(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RemoteIsReadyToHandleInputEvents", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendSetDimensions(
const DimensionRequest& aRequest,
const double& aScale) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SetDimensions(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aRequest);
// Sentinel = 'aRequest'
((&(writer__)))->WriteSentinel(238945099);
IPC::WriteParam((&(writer__)), aScale);
// Sentinel = 'aScale'
((&(writer__)))->WriteSentinel(131531338);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SetDimensions", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendDispatchWheelEvent(const WidgetWheelEvent& event) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DispatchWheelEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DispatchWheelEvent", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PBrowser::Msg_DispatchWheelEvent", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
return true;
}
auto PBrowserChild::SendDispatchMouseEvent(const WidgetMouseEvent& event) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DispatchMouseEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DispatchMouseEvent", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PBrowser::Msg_DispatchMouseEvent", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
return true;
}
auto PBrowserChild::SendDispatchKeyboardEvent(const WidgetKeyboardEvent& event) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DispatchKeyboardEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DispatchKeyboardEvent", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PBrowser::Msg_DispatchKeyboardEvent", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
return true;
}
auto PBrowserChild::SendDispatchTouchEvent(const WidgetTouchEvent& event) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DispatchTouchEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DispatchTouchEvent", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PBrowser::Msg_DispatchTouchEvent", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
return true;
}
auto PBrowserChild::SendInvokeDragSession(
nsTArray<IPCTransferableData>&& transfers,
const uint32_t& action,
mozilla::Maybe<BigBuffer>&& visualData,
const uint32_t& stride,
const SurfaceFormat& format,
const LayoutDeviceIntRect& dragRect,
nsIPrincipal* principal,
nsIContentSecurityPolicy* csp,
const CookieJarSettingsArgs& cookieJarSettings,
const MaybeDiscardedWindowContext& sourceWindowContext,
const MaybeDiscardedWindowContext& sourceTopWindowContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_InvokeDragSession(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), std::move(transfers));
// Sentinel = 'transfers'
((&(writer__)))->WriteSentinel(323290073);
IPC::WriteParam((&(writer__)), action);
// Sentinel = 'action'
((&(writer__)))->WriteSentinel(143786623);
IPC::WriteParam((&(writer__)), std::move(visualData));
// Sentinel = 'visualData'
((&(writer__)))->WriteSentinel(385877007);
IPC::WriteParam((&(writer__)), stride);
// Sentinel = 'stride'
((&(writer__)))->WriteSentinel(153879180);
IPC::WriteParam((&(writer__)), format);
// Sentinel = 'format'
((&(writer__)))->WriteSentinel(148505226);
IPC::WriteParam((&(writer__)), dragRect);
// Sentinel = 'dragRect'
((&(writer__)))->WriteSentinel(239076141);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
IPC::WriteParam((&(writer__)), csp);
// Sentinel = 'csp'
((&(writer__)))->WriteSentinel(42074439);
IPC::WriteParam((&(writer__)), cookieJarSettings);
// Sentinel = 'cookieJarSettings'
((&(writer__)))->WriteSentinel(1031800553);
IPC::WriteParam((&(writer__)), sourceWindowContext);
// Sentinel = 'sourceWindowContext'
((&(writer__)))->WriteSentinel(1328678895);
IPC::WriteParam((&(writer__)), sourceTopWindowContext);
// Sentinel = 'sourceTopWindowContext'
((&(writer__)))->WriteSentinel(1758005538);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_InvokeDragSession", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendEnsureLayersConnected(CompositorOptions* compositorOptions) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_EnsureLayersConnected(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_EnsureLayersConnected", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PBrowser::Msg_EnsureLayersConnected", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__compositorOptions__reply = IPC::ReadParam<CompositorOptions>((&(reader__)));
if (!maybe__compositorOptions__reply) {
FatalError("Error deserializing 'CompositorOptions'");
return false;
}
auto& compositorOptions__reply = *maybe__compositorOptions__reply;
// Sentinel = 'compositorOptions'
if ((!(((&(reader__)))->ReadSentinel(1089275708)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CompositorOptions'");
return false;
}
(*(compositorOptions)) = std::move(compositorOptions__reply);
reader__.EndRead();
return true;
}
auto PBrowserChild::SendShowCanvasPermissionPrompt(
const nsACString& aOrigin,
const bool& aHideDoorHanger) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ShowCanvasPermissionPrompt(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aOrigin);
// Sentinel = 'aOrigin'
((&(writer__)))->WriteSentinel(182125258);
IPC::WriteParam((&(writer__)), aHideDoorHanger);
// Sentinel = 'aHideDoorHanger'
((&(writer__)))->WriteSentinel(753731013);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ShowCanvasPermissionPrompt", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendSetSystemFont(const nsACString& aFontName) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SetSystemFont(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aFontName);
// Sentinel = 'aFontName'
((&(writer__)))->WriteSentinel(287114106);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SetSystemFont", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PBrowser::Msg_SetSystemFont", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
return true;
}
auto PBrowserChild::SendGetSystemFont(nsCString* retval) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_GetSystemFont(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_GetSystemFont", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PBrowser::Msg_GetSystemFont", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__retval__reply = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__retval__reply) {
FatalError("Error deserializing 'nsCString'");
return false;
}
auto& retval__reply = *maybe__retval__reply;
// Sentinel = 'retval'
if ((!(((&(reader__)))->ReadSentinel(151716495)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return false;
}
(*(retval)) = std::move(retval__reply);
reader__.EndRead();
return true;
}
auto PBrowserChild::SendMaybeFireEmbedderLoadEvents(const EmbedderElementEventType& aFireEventAtEmbeddingElement) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_MaybeFireEmbedderLoadEvents(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aFireEventAtEmbeddingElement);
// Sentinel = 'aFireEventAtEmbeddingElement'
((&(writer__)))->WriteSentinel(2607483624);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_MaybeFireEmbedderLoadEvents", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendScrollRectIntoView(
const nsRect& aRect,
const ScrollAxis& aVertical,
const ScrollAxis& aHorizontal,
const ScrollFlags& aScrollFlags,
const int32_t& aAppUnitsPerDevPixel) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ScrollRectIntoView(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aRect);
// Sentinel = 'aRect'
((&(writer__)))->WriteSentinel(94044656);
IPC::WriteParam((&(writer__)), aVertical);
// Sentinel = 'aVertical'
((&(writer__)))->WriteSentinel(298845084);
IPC::WriteParam((&(writer__)), aHorizontal);
// Sentinel = 'aHorizontal'
((&(writer__)))->WriteSentinel(447022220);
IPC::WriteParam((&(writer__)), aScrollFlags);
// Sentinel = 'aScrollFlags'
((&(writer__)))->WriteSentinel(510592190);
IPC::WriteParam((&(writer__)), aAppUnitsPerDevPixel);
// Sentinel = 'aAppUnitsPerDevPixel'
((&(writer__)))->WriteSentinel(1366296542);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ScrollRectIntoView", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendShowDynamicToolbar() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ShowDynamicToolbar(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ShowDynamicToolbar", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendIsWindowSupportingProtectedMedia(
const uint64_t& aOuterWindowID,
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_IsWindowSupportingProtectedMedia(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aOuterWindowID);
// Sentinel = 'aOuterWindowID'
((&(writer__)))->WriteSentinel(702612854);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_IsWindowSupportingProtectedMedia", OTHER);
ChannelSend(std::move(msg__), PBrowser::Reply_IsWindowSupportingProtectedMedia__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PBrowserChild::SendIsWindowSupportingProtectedMedia(const uint64_t& aOuterWindowID) -> RefPtr<IsWindowSupportingProtectedMediaPromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendIsWindowSupportingProtectedMedia(std::move(aOuterWindowID), [promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PBrowserChild::SendIsWindowSupportingWebVR(
const uint64_t& aOuterWindowID,
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_IsWindowSupportingWebVR(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aOuterWindowID);
// Sentinel = 'aOuterWindowID'
((&(writer__)))->WriteSentinel(702612854);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_IsWindowSupportingWebVR", OTHER);
ChannelSend(std::move(msg__), PBrowser::Reply_IsWindowSupportingWebVR__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PBrowserChild::SendIsWindowSupportingWebVR(const uint64_t& aOuterWindowID) -> RefPtr<IsWindowSupportingWebVRPromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendIsWindowSupportingWebVR(std::move(aOuterWindowID), [promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PBrowserChild::SendVisitURI(
nsIURI* aURI,
nsIURI* aLastVisitedURI,
const uint32_t& aFlags,
const uint64_t& aBrowserId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_VisitURI(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aURI);
// Sentinel = 'aURI'
((&(writer__)))->WriteSentinel(57934162);
IPC::WriteParam((&(writer__)), aLastVisitedURI);
// Sentinel = 'aLastVisitedURI'
((&(writer__)))->WriteSentinel(786695614);
IPC::WriteParam((&(writer__)), aFlags);
// Sentinel = 'aFlags'
((&(writer__)))->WriteSentinel(129892943);
IPC::WriteParam((&(writer__)), aBrowserId);
// Sentinel = 'aBrowserId'
((&(writer__)))->WriteSentinel(363332595);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_VisitURI", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendQueryVisitedState(mozilla::Span<RefPtr<nsIURI> const> aURIs) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_QueryVisitedState(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aURIs);
// Sentinel = 'aURIs'
((&(writer__)))->WriteSentinel(87622085);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_QueryVisitedState", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::SendPSessionStoreConstructor(PSessionStoreChild* actor) -> PSessionStoreChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PSessionStoreChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPSessionStoreChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PSessionStoreChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_PSessionStoreConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PSessionStoreConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PSessionStoreChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PBrowserChild::SendNewWindowGlobal(
ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>&& aEndpoint,
const WindowGlobalInit& aInit) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NewWindowGlobal(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), std::move(aEndpoint));
// Sentinel = 'aEndpoint'
((&(writer__)))->WriteSentinel(292225955);
IPC::WriteParam((&(writer__)), aInit);
// Sentinel = 'aInit'
((&(writer__)))->WriteSentinel(94241270);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NewWindowGlobal", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserChild::RemoveManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
switch (aProtocolId) {
case PColorPickerMsgStart:
MOZ_ALWAYS_TRUE(mManagedPColorPickerChild.EnsureRemoved(static_cast<PColorPickerChild*>(aListener)));
return;
case PDocAccessibleMsgStart:
MOZ_ALWAYS_TRUE(mManagedPDocAccessibleChild.EnsureRemoved(static_cast<PDocAccessibleChild*>(aListener)));
return;
case PFilePickerMsgStart:
MOZ_ALWAYS_TRUE(mManagedPFilePickerChild.EnsureRemoved(static_cast<PFilePickerChild*>(aListener)));
return;
case PPaymentRequestMsgStart:
MOZ_ALWAYS_TRUE(mManagedPPaymentRequestChild.EnsureRemoved(static_cast<PPaymentRequestChild*>(aListener)));
return;
case PSessionStoreMsgStart:
MOZ_ALWAYS_TRUE(mManagedPSessionStoreChild.EnsureRemoved(static_cast<PSessionStoreChild*>(aListener)));
return;
case PWindowGlobalMsgStart:
MOZ_ALWAYS_TRUE(mManagedPWindowGlobalChild.EnsureRemoved(static_cast<PWindowGlobalChild*>(aListener)));
return;
case PBrowserBridgeMsgStart:
MOZ_ALWAYS_TRUE(mManagedPBrowserBridgeChild.EnsureRemoved(static_cast<PBrowserBridgeChild*>(aListener)));
return;
case PVsyncMsgStart:
MOZ_ALWAYS_TRUE(mManagedPVsyncChild.EnsureRemoved(static_cast<PVsyncChild*>(aListener)));
return;
default:
FatalError("unreached");
return; }
}
auto PBrowserChild::DeallocManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
switch (aProtocolId) {
case PDocAccessibleMsgStart:
static_cast<BrowserChild*>(this)->DeallocPDocAccessibleChild(static_cast<PDocAccessibleChild*>(aListener));
return;
case PPaymentRequestMsgStart:
static_cast<BrowserChild*>(this)->DeallocPPaymentRequestChild(static_cast<PPaymentRequestChild*>(aListener));
return;
default:
FatalError("unreached");
return;
}
}
auto PBrowserChild::OnMessageReceived(const Message& msg__) -> PBrowserChild::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;
this->ActorDisconnected(ManagedEndpointDropped);
return MsgProcessed;
}
case PBrowser::Msg_AsyncMessage__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_AsyncMessage", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aMessage = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aMessage) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aMessage = *maybe__aMessage;
// Sentinel = 'aMessage'
if ((!(((&(reader__)))->ReadSentinel(233440039)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aData = IPC::ReadParam<ClonedMessageData>((&(reader__)));
if (!maybe__aData) {
FatalError("Error deserializing 'ClonedMessageData'");
return MsgValueError;
}
auto& aData = *maybe__aData;
// Sentinel = 'aData'
if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvAsyncMessage(std::move(aMessage), std::move(aData));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Reply_PDocAccessibleConstructor__ID:
{
return MsgProcessed;
}
case PBrowser::Reply_PPaymentRequestConstructor__ID:
{
return MsgProcessed;
}
case PBrowser::Reply_PVsyncConstructor__ID:
{
return MsgProcessed;
}
case PBrowser::Reply_NotifyIMEFocus__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMEFocus", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<IMENotificationRequests> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__requests = IPC::ReadParam<IMENotificationRequests>((&(reader__)));
if (!maybe__requests) {
FatalError("Error deserializing 'IMENotificationRequests'");
return MsgValueError;
}
auto& requests = *maybe__requests;
// Sentinel = 'requests'
if ((!(((&(reader__)))->ReadSentinel(261227389)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IMENotificationRequests'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(requests));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PBrowser::Reply_PColorPickerConstructor__ID:
{
return MsgProcessed;
}
case PBrowser::Reply_PFilePickerConstructor__ID:
{
return MsgProcessed;
}
case PBrowser::Reply___delete____ID:
{
return MsgProcessed;
}
case PBrowser::Reply_RequestPointerLock__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RequestPointerLock", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<nsCString> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__error = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__error) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& error = *maybe__error;
// Sentinel = 'error'
if ((!(((&(reader__)))->ReadSentinel(107741739)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(error));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PBrowser::Reply_RequestPointerCapture__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RequestPointerCapture", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<bool> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__aSuccess = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aSuccess) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aSuccess = *maybe__aSuccess;
// Sentinel = 'aSuccess'
if ((!(((&(reader__)))->ReadSentinel(236323643)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(aSuccess));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PBrowser::Msg_NativeSynthesisResponse__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NativeSynthesisResponse", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aObserverId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aObserverId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aObserverId = *maybe__aObserverId;
// Sentinel = 'aObserverId'
if ((!(((&(reader__)))->ReadSentinel(435356759)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aResponse = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aResponse) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aResponse = *maybe__aResponse;
// Sentinel = 'aResponse'
if ((!(((&(reader__)))->ReadSentinel(301466545)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNativeSynthesisResponse(std::move(aObserverId), std::move(aResponse));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_UpdateSHistory__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateSHistory", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvUpdateSHistory();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_CloneDocumentTreeIntoSelf__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_CloneDocumentTreeIntoSelf", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aBc = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aBc) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aBc = *maybe__aBc;
// Sentinel = 'aBc'
if ((!(((&(reader__)))->ReadSentinel(34406663)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aPrintData = IPC::ReadParam<PrintData>((&(reader__)));
if (!maybe__aPrintData) {
FatalError("Error deserializing 'PrintData'");
return MsgValueError;
}
auto& aPrintData = *maybe__aPrintData;
// Sentinel = 'aPrintData'
if ((!(((&(reader__)))->ReadSentinel(359072745)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PrintData'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PBrowser::Reply_CloneDocumentTreeIntoSelf(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
CloneDocumentTreeIntoSelfResolver resolver = [resolver__ = std::move(resolver__)](const bool& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'aSuccess'
((&(writer__)))->WriteSentinel(236323643);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvCloneDocumentTreeIntoSelf(std::move(aBc), std::move(aPrintData), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_UpdateRemotePrintSettings__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateRemotePrintSettings", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPrintData = IPC::ReadParam<PrintData>((&(reader__)));
if (!maybe__aPrintData) {
FatalError("Error deserializing 'PrintData'");
return MsgValueError;
}
auto& aPrintData = *maybe__aPrintData;
// Sentinel = 'aPrintData'
if ((!(((&(reader__)))->ReadSentinel(359072745)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PrintData'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvUpdateRemotePrintSettings(std::move(aPrintData));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_ReleaseAllPointerCapture__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ReleaseAllPointerCapture", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvReleaseAllPointerCapture();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_UpdateEffects__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateEffects", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEffects = IPC::ReadParam<EffectsInfo>((&(reader__)));
if (!maybe__aEffects) {
FatalError("Error deserializing 'EffectsInfo'");
return MsgValueError;
}
auto& aEffects = *maybe__aEffects;
// Sentinel = 'aEffects'
if ((!(((&(reader__)))->ReadSentinel(225248034)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'EffectsInfo'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvUpdateEffects(std::move(aEffects));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_Show__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_Show", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__parentInfo = IPC::ReadParam<ParentShowInfo>((&(reader__)));
if (!maybe__parentInfo) {
FatalError("Error deserializing 'ParentShowInfo'");
return MsgValueError;
}
auto& parentInfo = *maybe__parentInfo;
// Sentinel = 'parentInfo'
if ((!(((&(reader__)))->ReadSentinel(380044311)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ParentShowInfo'");
return MsgValueError;
}
auto maybe__childInfo = IPC::ReadParam<OwnerShowInfo>((&(reader__)));
if (!maybe__childInfo) {
FatalError("Error deserializing 'OwnerShowInfo'");
return MsgValueError;
}
auto& childInfo = *maybe__childInfo;
// Sentinel = 'childInfo'
if ((!(((&(reader__)))->ReadSentinel(298320785)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'OwnerShowInfo'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvShow(std::move(parentInfo), std::move(childInfo));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_Activate__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_Activate", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvActivate(std::move(aActionId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_Deactivate__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_Deactivate", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvDeactivate(std::move(aActionId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_ScrollbarPreferenceChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ScrollbarPreferenceChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__pref = IPC::ReadParam<ScrollbarPreference>((&(reader__)));
if (!maybe__pref) {
FatalError("Error deserializing 'ScrollbarPreference'");
return MsgValueError;
}
auto& pref = *maybe__pref;
// Sentinel = 'pref'
if ((!(((&(reader__)))->ReadSentinel(71958958)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollbarPreference'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvScrollbarPreferenceChanged(std::move(pref));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_InitRendering__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_InitRendering", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__textureFactoryIdentifier = IPC::ReadParam<TextureFactoryIdentifier>((&(reader__)));
if (!maybe__textureFactoryIdentifier) {
FatalError("Error deserializing 'TextureFactoryIdentifier'");
return MsgValueError;
}
auto& textureFactoryIdentifier = *maybe__textureFactoryIdentifier;
// Sentinel = 'textureFactoryIdentifier'
if ((!(((&(reader__)))->ReadSentinel(2096630253)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TextureFactoryIdentifier'");
return MsgValueError;
}
auto maybe__layersId = IPC::ReadParam<LayersId>((&(reader__)));
if (!maybe__layersId) {
FatalError("Error deserializing 'LayersId'");
return MsgValueError;
}
auto& layersId = *maybe__layersId;
// Sentinel = 'layersId'
if ((!(((&(reader__)))->ReadSentinel(250938174)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
return MsgValueError;
}
auto maybe__compositorOptions = IPC::ReadParam<CompositorOptions>((&(reader__)));
if (!maybe__compositorOptions) {
FatalError("Error deserializing 'CompositorOptions'");
return MsgValueError;
}
auto& compositorOptions = *maybe__compositorOptions;
// Sentinel = 'compositorOptions'
if ((!(((&(reader__)))->ReadSentinel(1089275708)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CompositorOptions'");
return MsgValueError;
}
auto maybe__layersConnected = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__layersConnected) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& layersConnected = *maybe__layersConnected;
// Sentinel = 'layersConnected'
if ((!(((&(reader__)))->ReadSentinel(829294116)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvInitRendering(std::move(textureFactoryIdentifier), std::move(layersId), std::move(compositorOptions), std::move(layersConnected));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_CompositorOptionsChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_CompositorOptionsChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__newOptions = IPC::ReadParam<CompositorOptions>((&(reader__)));
if (!maybe__newOptions) {
FatalError("Error deserializing 'CompositorOptions'");
return MsgValueError;
}
auto& newOptions = *maybe__newOptions;
// Sentinel = 'newOptions'
if ((!(((&(reader__)))->ReadSentinel(384304183)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CompositorOptions'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvCompositorOptionsChanged(std::move(newOptions));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_LoadURL__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_LoadURL", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__loadState = IPC::ReadParam<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>((&(reader__)));
if (!maybe__loadState) {
FatalError("Error deserializing 'NotNull<nsDocShellLoadState>'");
return MsgValueError;
}
auto& loadState = *maybe__loadState;
// Sentinel = 'loadState'
if ((!(((&(reader__)))->ReadSentinel(304808866)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsDocShellLoadState>'");
return MsgValueError;
}
auto maybe__info = IPC::ReadParam<ParentShowInfo>((&(reader__)));
if (!maybe__info) {
FatalError("Error deserializing 'ParentShowInfo'");
return MsgValueError;
}
auto& info = *maybe__info;
// Sentinel = 'info'
if ((!(((&(reader__)))->ReadSentinel(70058413)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ParentShowInfo'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvLoadURL(loadState, std::move(info));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_CreateAboutBlankDocumentViewer__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_CreateAboutBlankDocumentViewer", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__principal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__principal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& principal = *maybe__principal;
// Sentinel = 'principal'
if ((!(((&(reader__)))->ReadSentinel(319620035)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__partitionedPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__partitionedPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& partitionedPrincipal = *maybe__partitionedPrincipal;
// Sentinel = 'partitionedPrincipal'
if ((!(((&(reader__)))->ReadSentinel(1472661574)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvCreateAboutBlankDocumentViewer(principal, partitionedPrincipal);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_ResumeLoad__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ResumeLoad", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__pendingSwitchID = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__pendingSwitchID) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& pendingSwitchID = *maybe__pendingSwitchID;
// Sentinel = 'pendingSwitchID'
if ((!(((&(reader__)))->ReadSentinel(822478309)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__info = IPC::ReadParam<ParentShowInfo>((&(reader__)));
if (!maybe__info) {
FatalError("Error deserializing 'ParentShowInfo'");
return MsgValueError;
}
auto& info = *maybe__info;
// Sentinel = 'info'
if ((!(((&(reader__)))->ReadSentinel(70058413)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ParentShowInfo'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvResumeLoad(std::move(pendingSwitchID), std::move(info));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_UpdateDimensions__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateDimensions", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__dimensions = IPC::ReadParam<DimensionInfo>((&(reader__)));
if (!maybe__dimensions) {
FatalError("Error deserializing 'DimensionInfo'");
return MsgValueError;
}
auto& dimensions = *maybe__dimensions;
// Sentinel = 'dimensions'
if ((!(((&(reader__)))->ReadSentinel(383845434)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'DimensionInfo'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvUpdateDimensions(std::move(dimensions));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SizeModeChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SizeModeChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__sizeMode = IPC::ReadParam<nsSizeMode>((&(reader__)));
if (!maybe__sizeMode) {
FatalError("Error deserializing 'nsSizeMode'");
return MsgValueError;
}
auto& sizeMode = *maybe__sizeMode;
// Sentinel = 'sizeMode'
if ((!(((&(reader__)))->ReadSentinel(251790145)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsSizeMode'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvSizeModeChanged(std::move(sizeMode));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_ChildToParentMatrix__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ChildToParentMatrix", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aMatrix = IPC::ReadParam<mozilla::Maybe<Matrix4x4>>((&(reader__)));
if (!maybe__aMatrix) {
FatalError("Error deserializing 'Matrix4x4?'");
return MsgValueError;
}
auto& aMatrix = *maybe__aMatrix;
// Sentinel = 'aMatrix'
if ((!(((&(reader__)))->ReadSentinel(181469911)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Matrix4x4?'");
return MsgValueError;
}
auto maybe__aRemoteDocumentRect = IPC::ReadParam<ScreenRect>((&(reader__)));
if (!maybe__aRemoteDocumentRect) {
FatalError("Error deserializing 'ScreenRect'");
return MsgValueError;
}
auto& aRemoteDocumentRect = *maybe__aRemoteDocumentRect;
// Sentinel = 'aRemoteDocumentRect'
if ((!(((&(reader__)))->ReadSentinel(1261242267)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScreenRect'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvChildToParentMatrix(std::move(aMatrix), std::move(aRemoteDocumentRect));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_UpdateRemoteStyle__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateRemoteStyle", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aImageRendering = IPC::ReadParam<StyleImageRendering>((&(reader__)));
if (!maybe__aImageRendering) {
FatalError("Error deserializing 'StyleImageRendering'");
return MsgValueError;
}
auto& aImageRendering = *maybe__aImageRendering;
// Sentinel = 'aImageRendering'
if ((!(((&(reader__)))->ReadSentinel(768804323)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'StyleImageRendering'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvUpdateRemoteStyle(std::move(aImageRendering));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_DynamicToolbarMaxHeightChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DynamicToolbarMaxHeightChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__height = IPC::ReadParam<ScreenIntCoord>((&(reader__)));
if (!maybe__height) {
FatalError("Error deserializing 'ScreenIntCoord'");
return MsgValueError;
}
auto& height = *maybe__height;
// Sentinel = 'height'
if ((!(((&(reader__)))->ReadSentinel(143393402)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScreenIntCoord'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvDynamicToolbarMaxHeightChanged(std::move(height));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_DynamicToolbarOffsetChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DynamicToolbarOffsetChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__height = IPC::ReadParam<ScreenIntCoord>((&(reader__)));
if (!maybe__height) {
FatalError("Error deserializing 'ScreenIntCoord'");
return MsgValueError;
}
auto& height = *maybe__height;
// Sentinel = 'height'
if ((!(((&(reader__)))->ReadSentinel(143393402)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScreenIntCoord'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvDynamicToolbarOffsetChanged(std::move(height));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_StopIMEStateManagement__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_StopIMEStateManagement", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvStopIMEStateManagement();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_RealMouseMoveEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealMouseMoveEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetMouseEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealMouseMoveEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NormalPriorityRealMouseMoveEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealMouseMoveEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetMouseEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealMouseMoveEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_RealMouseMoveEventForTests__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealMouseMoveEventForTests", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetMouseEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealMouseMoveEventForTests(std::move(event), std::move(aGuid), std::move(aInputBlockId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NormalPriorityRealMouseMoveEventForTests__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealMouseMoveEventForTests", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetMouseEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealMouseMoveEventForTests(std::move(event), std::move(aGuid), std::move(aInputBlockId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SynthMouseMoveEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthMouseMoveEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetMouseEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvSynthMouseMoveEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NormalPrioritySynthMouseMoveEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPrioritySynthMouseMoveEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetMouseEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPrioritySynthMouseMoveEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_RealMouseButtonEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealMouseButtonEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetMouseEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealMouseButtonEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NormalPriorityRealMouseButtonEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealMouseButtonEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetMouseEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealMouseButtonEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_RealMouseEnterExitWidgetEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealMouseEnterExitWidgetEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetMouseEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealMouseEnterExitWidgetEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NormalPriorityRealMouseEnterExitWidgetEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealMouseEnterExitWidgetEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetMouseEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetMouseEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealMouseEnterExitWidgetEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_RealKeyEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealKeyEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEvent = IPC::ReadParam<WidgetKeyboardEvent>((&(reader__)));
if (!maybe__aEvent) {
FatalError("Error deserializing 'WidgetKeyboardEvent'");
return MsgValueError;
}
auto& aEvent = *maybe__aEvent;
// Sentinel = 'aEvent'
if ((!(((&(reader__)))->ReadSentinel(133956196)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetKeyboardEvent'");
return MsgValueError;
}
auto maybe__aUUID = IPC::ReadParam<nsID>((&(reader__)));
if (!maybe__aUUID) {
FatalError("Error deserializing 'nsID'");
return MsgValueError;
}
auto& aUUID = *maybe__aUUID;
// Sentinel = 'aUUID'
if ((!(((&(reader__)))->ReadSentinel(85131673)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealKeyEvent(std::move(aEvent), std::move(aUUID));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NormalPriorityRealKeyEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealKeyEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEvent = IPC::ReadParam<WidgetKeyboardEvent>((&(reader__)));
if (!maybe__aEvent) {
FatalError("Error deserializing 'WidgetKeyboardEvent'");
return MsgValueError;
}
auto& aEvent = *maybe__aEvent;
// Sentinel = 'aEvent'
if ((!(((&(reader__)))->ReadSentinel(133956196)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetKeyboardEvent'");
return MsgValueError;
}
auto maybe__aUUID = IPC::ReadParam<nsID>((&(reader__)));
if (!maybe__aUUID) {
FatalError("Error deserializing 'nsID'");
return MsgValueError;
}
auto& aUUID = *maybe__aUUID;
// Sentinel = 'aUUID'
if ((!(((&(reader__)))->ReadSentinel(85131673)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealKeyEvent(std::move(aEvent), std::move(aUUID));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_MouseWheelEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_MouseWheelEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetWheelEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetWheelEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetWheelEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvMouseWheelEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NormalPriorityMouseWheelEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityMouseWheelEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetWheelEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetWheelEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetWheelEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityMouseWheelEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_RealTouchEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealTouchEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEvent = IPC::ReadParam<WidgetTouchEvent>((&(reader__)));
if (!maybe__aEvent) {
FatalError("Error deserializing 'WidgetTouchEvent'");
return MsgValueError;
}
auto& aEvent = *maybe__aEvent;
// Sentinel = 'aEvent'
if ((!(((&(reader__)))->ReadSentinel(133956196)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetTouchEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aApzResponse = IPC::ReadParam<nsEventStatus>((&(reader__)));
if (!maybe__aApzResponse) {
FatalError("Error deserializing 'nsEventStatus'");
return MsgValueError;
}
auto& aApzResponse = *maybe__aApzResponse;
// Sentinel = 'aApzResponse'
if ((!(((&(reader__)))->ReadSentinel(512951516)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsEventStatus'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealTouchEvent(std::move(aEvent), std::move(aGuid), std::move(aInputBlockId), std::move(aApzResponse));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NormalPriorityRealTouchEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealTouchEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEvent = IPC::ReadParam<WidgetTouchEvent>((&(reader__)));
if (!maybe__aEvent) {
FatalError("Error deserializing 'WidgetTouchEvent'");
return MsgValueError;
}
auto& aEvent = *maybe__aEvent;
// Sentinel = 'aEvent'
if ((!(((&(reader__)))->ReadSentinel(133956196)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetTouchEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aApzResponse = IPC::ReadParam<nsEventStatus>((&(reader__)));
if (!maybe__aApzResponse) {
FatalError("Error deserializing 'nsEventStatus'");
return MsgValueError;
}
auto& aApzResponse = *maybe__aApzResponse;
// Sentinel = 'aApzResponse'
if ((!(((&(reader__)))->ReadSentinel(512951516)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsEventStatus'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealTouchEvent(std::move(aEvent), std::move(aGuid), std::move(aInputBlockId), std::move(aApzResponse));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_HandleTap__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_HandleTap", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aType = IPC::ReadParam<GeckoContentController_TapType>((&(reader__)));
if (!maybe__aType) {
FatalError("Error deserializing 'GeckoContentController_TapType'");
return MsgValueError;
}
auto& aType = *maybe__aType;
// Sentinel = 'aType'
if ((!(((&(reader__)))->ReadSentinel(99222020)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'GeckoContentController_TapType'");
return MsgValueError;
}
auto maybe__point = IPC::ReadParam<LayoutDevicePoint>((&(reader__)));
if (!maybe__point) {
FatalError("Error deserializing 'LayoutDevicePoint'");
return MsgValueError;
}
auto& point = *maybe__point;
// Sentinel = 'point'
if ((!(((&(reader__)))->ReadSentinel(108790315)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDevicePoint'");
return MsgValueError;
}
auto maybe__aModifiers = IPC::ReadParam<Modifiers>((&(reader__)));
if (!maybe__aModifiers) {
FatalError("Error deserializing 'Modifiers'");
return MsgValueError;
}
auto& aModifiers = *maybe__aModifiers;
// Sentinel = 'aModifiers'
if ((!(((&(reader__)))->ReadSentinel(358286340)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Modifiers'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aMetrics = IPC::ReadParam<mozilla::Maybe<DoubleTapToZoomMetrics>>((&(reader__)));
if (!maybe__aMetrics) {
FatalError("Error deserializing 'DoubleTapToZoomMetrics?'");
return MsgValueError;
}
auto& aMetrics = *maybe__aMetrics;
// Sentinel = 'aMetrics'
if ((!(((&(reader__)))->ReadSentinel(235471673)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'DoubleTapToZoomMetrics?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvHandleTap(std::move(aType), std::move(point), std::move(aModifiers), std::move(aGuid), std::move(aInputBlockId), std::move(aMetrics));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NormalPriorityHandleTap__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityHandleTap", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aType = IPC::ReadParam<GeckoContentController_TapType>((&(reader__)));
if (!maybe__aType) {
FatalError("Error deserializing 'GeckoContentController_TapType'");
return MsgValueError;
}
auto& aType = *maybe__aType;
// Sentinel = 'aType'
if ((!(((&(reader__)))->ReadSentinel(99222020)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'GeckoContentController_TapType'");
return MsgValueError;
}
auto maybe__point = IPC::ReadParam<LayoutDevicePoint>((&(reader__)));
if (!maybe__point) {
FatalError("Error deserializing 'LayoutDevicePoint'");
return MsgValueError;
}
auto& point = *maybe__point;
// Sentinel = 'point'
if ((!(((&(reader__)))->ReadSentinel(108790315)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDevicePoint'");
return MsgValueError;
}
auto maybe__aModifiers = IPC::ReadParam<Modifiers>((&(reader__)));
if (!maybe__aModifiers) {
FatalError("Error deserializing 'Modifiers'");
return MsgValueError;
}
auto& aModifiers = *maybe__aModifiers;
// Sentinel = 'aModifiers'
if ((!(((&(reader__)))->ReadSentinel(358286340)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Modifiers'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aMetrics = IPC::ReadParam<mozilla::Maybe<DoubleTapToZoomMetrics>>((&(reader__)));
if (!maybe__aMetrics) {
FatalError("Error deserializing 'DoubleTapToZoomMetrics?'");
return MsgValueError;
}
auto& aMetrics = *maybe__aMetrics;
// Sentinel = 'aMetrics'
if ((!(((&(reader__)))->ReadSentinel(235471673)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'DoubleTapToZoomMetrics?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityHandleTap(std::move(aType), std::move(point), std::move(aModifiers), std::move(aGuid), std::move(aInputBlockId), std::move(aMetrics));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_RealTouchMoveEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealTouchMoveEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEvent = IPC::ReadParam<WidgetTouchEvent>((&(reader__)));
if (!maybe__aEvent) {
FatalError("Error deserializing 'WidgetTouchEvent'");
return MsgValueError;
}
auto& aEvent = *maybe__aEvent;
// Sentinel = 'aEvent'
if ((!(((&(reader__)))->ReadSentinel(133956196)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetTouchEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aApzResponse = IPC::ReadParam<nsEventStatus>((&(reader__)));
if (!maybe__aApzResponse) {
FatalError("Error deserializing 'nsEventStatus'");
return MsgValueError;
}
auto& aApzResponse = *maybe__aApzResponse;
// Sentinel = 'aApzResponse'
if ((!(((&(reader__)))->ReadSentinel(512951516)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsEventStatus'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealTouchMoveEvent(std::move(aEvent), std::move(aGuid), std::move(aInputBlockId), std::move(aApzResponse));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NormalPriorityRealTouchMoveEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealTouchMoveEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEvent = IPC::ReadParam<WidgetTouchEvent>((&(reader__)));
if (!maybe__aEvent) {
FatalError("Error deserializing 'WidgetTouchEvent'");
return MsgValueError;
}
auto& aEvent = *maybe__aEvent;
// Sentinel = 'aEvent'
if ((!(((&(reader__)))->ReadSentinel(133956196)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetTouchEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aApzResponse = IPC::ReadParam<nsEventStatus>((&(reader__)));
if (!maybe__aApzResponse) {
FatalError("Error deserializing 'nsEventStatus'");
return MsgValueError;
}
auto& aApzResponse = *maybe__aApzResponse;
// Sentinel = 'aApzResponse'
if ((!(((&(reader__)))->ReadSentinel(512951516)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsEventStatus'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealTouchMoveEvent(std::move(aEvent), std::move(aGuid), std::move(aInputBlockId), std::move(aApzResponse));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_RealTouchMoveEvent2__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealTouchMoveEvent2", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEvent = IPC::ReadParam<WidgetTouchEvent>((&(reader__)));
if (!maybe__aEvent) {
FatalError("Error deserializing 'WidgetTouchEvent'");
return MsgValueError;
}
auto& aEvent = *maybe__aEvent;
// Sentinel = 'aEvent'
if ((!(((&(reader__)))->ReadSentinel(133956196)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetTouchEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aApzResponse = IPC::ReadParam<nsEventStatus>((&(reader__)));
if (!maybe__aApzResponse) {
FatalError("Error deserializing 'nsEventStatus'");
return MsgValueError;
}
auto& aApzResponse = *maybe__aApzResponse;
// Sentinel = 'aApzResponse'
if ((!(((&(reader__)))->ReadSentinel(512951516)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsEventStatus'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealTouchMoveEvent2(std::move(aEvent), std::move(aGuid), std::move(aInputBlockId), std::move(aApzResponse));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NormalPriorityRealTouchMoveEvent2__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealTouchMoveEvent2", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEvent = IPC::ReadParam<WidgetTouchEvent>((&(reader__)));
if (!maybe__aEvent) {
FatalError("Error deserializing 'WidgetTouchEvent'");
return MsgValueError;
}
auto& aEvent = *maybe__aEvent;
// Sentinel = 'aEvent'
if ((!(((&(reader__)))->ReadSentinel(133956196)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetTouchEvent'");
return MsgValueError;
}
auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
if (!maybe__aGuid) {
FatalError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto& aGuid = *maybe__aGuid;
// Sentinel = 'aGuid'
if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
return MsgValueError;
}
auto maybe__aInputBlockId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInputBlockId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInputBlockId = *maybe__aInputBlockId;
// Sentinel = 'aInputBlockId'
if ((!(((&(reader__)))->ReadSentinel(595657994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aApzResponse = IPC::ReadParam<nsEventStatus>((&(reader__)));
if (!maybe__aApzResponse) {
FatalError("Error deserializing 'nsEventStatus'");
return MsgValueError;
}
auto& aApzResponse = *maybe__aApzResponse;
// Sentinel = 'aApzResponse'
if ((!(((&(reader__)))->ReadSentinel(512951516)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsEventStatus'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealTouchMoveEvent2(std::move(aEvent), std::move(aGuid), std::move(aInputBlockId), std::move(aApzResponse));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_RealDragEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealDragEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEvent = IPC::ReadParam<WidgetDragEvent>((&(reader__)));
if (!maybe__aEvent) {
FatalError("Error deserializing 'WidgetDragEvent'");
return MsgValueError;
}
auto& aEvent = *maybe__aEvent;
// Sentinel = 'aEvent'
if ((!(((&(reader__)))->ReadSentinel(133956196)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetDragEvent'");
return MsgValueError;
}
auto maybe__aDragAction = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aDragAction) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aDragAction = *maybe__aDragAction;
// Sentinel = 'aDragAction'
if ((!(((&(reader__)))->ReadSentinel(411370558)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aDropEffect = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aDropEffect) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aDropEffect = *maybe__aDropEffect;
// Sentinel = 'aDropEffect'
if ((!(((&(reader__)))->ReadSentinel(419759172)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aPrincipal = *maybe__aPrincipal;
// Sentinel = 'aPrincipal'
if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__csp = IPC::ReadParam<RefPtr<nsIContentSecurityPolicy>>((&(reader__)));
if (!maybe__csp) {
FatalError("Error deserializing 'nsIContentSecurityPolicy'");
return MsgValueError;
}
auto& csp = *maybe__csp;
// Sentinel = 'csp'
if ((!(((&(reader__)))->ReadSentinel(42074439)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIContentSecurityPolicy'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealDragEvent(std::move(aEvent), std::move(aDragAction), std::move(aDropEffect), aPrincipal, csp);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_CompositionEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_CompositionEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetCompositionEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetCompositionEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetCompositionEvent'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvCompositionEvent(std::move(event));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NormalPriorityCompositionEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityCompositionEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetCompositionEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetCompositionEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetCompositionEvent'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityCompositionEvent(std::move(event));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SelectionEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SelectionEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetSelectionEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetSelectionEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetSelectionEvent'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvSelectionEvent(std::move(event));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NormalPrioritySelectionEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPrioritySelectionEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetSelectionEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetSelectionEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetSelectionEvent'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPrioritySelectionEvent(std::move(event));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_InsertText__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_InsertText", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aStringToInsert = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aStringToInsert) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aStringToInsert = *maybe__aStringToInsert;
// Sentinel = 'aStringToInsert'
if ((!(((&(reader__)))->ReadSentinel(801768977)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvInsertText(std::move(aStringToInsert));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NormalPriorityInsertText__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityInsertText", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aStringToInsert = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aStringToInsert) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aStringToInsert = *maybe__aStringToInsert;
// Sentinel = 'aStringToInsert'
if ((!(((&(reader__)))->ReadSentinel(801768977)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityInsertText(std::move(aStringToInsert));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_PasteTransferable__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PasteTransferable", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aTransferable = IPC::ReadParam<IPCTransferable>((&(reader__)));
if (!maybe__aTransferable) {
FatalError("Error deserializing 'IPCTransferable'");
return MsgValueError;
}
auto& aTransferable = *maybe__aTransferable;
// Sentinel = 'aTransferable'
if ((!(((&(reader__)))->ReadSentinel(609813819)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCTransferable'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvPasteTransferable(std::move(aTransferable));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_LoadRemoteScript__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_LoadRemoteScript", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aURL = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aURL) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aURL = *maybe__aURL;
// Sentinel = 'aURL'
if ((!(((&(reader__)))->ReadSentinel(58130773)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aRunInGlobalScope = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aRunInGlobalScope) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aRunInGlobalScope = *maybe__aRunInGlobalScope;
// Sentinel = 'aRunInGlobalScope'
if ((!(((&(reader__)))->ReadSentinel(981862041)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvLoadRemoteScript(std::move(aURL), std::move(aRunInGlobalScope));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_Destroy__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_Destroy", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvDestroy();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_RenderLayers__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RenderLayers", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEnabled = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aEnabled) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aEnabled = *maybe__aEnabled;
// Sentinel = 'aEnabled'
if ((!(((&(reader__)))->ReadSentinel(224789261)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRenderLayers(std::move(aEnabled));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_PreserveLayers__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PreserveLayers", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPreserve = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aPreserve) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aPreserve = *maybe__aPreserve;
// Sentinel = 'aPreserve'
if ((!(((&(reader__)))->ReadSentinel(300417966)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvPreserveLayers(std::move(aPreserve));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SuppressDisplayport__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SuppressDisplayport", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEnabled = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aEnabled) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aEnabled = *maybe__aEnabled;
// Sentinel = 'aEnabled'
if ((!(((&(reader__)))->ReadSentinel(224789261)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvSuppressDisplayport(std::move(aEnabled));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NavigateByKey__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NavigateByKey", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aForward = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aForward) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aForward = *maybe__aForward;
// Sentinel = 'aForward'
if ((!(((&(reader__)))->ReadSentinel(236258103)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aForDocumentNavigation = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aForDocumentNavigation) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aForDocumentNavigation = *maybe__aForDocumentNavigation;
// Sentinel = 'aForDocumentNavigation'
if ((!(((&(reader__)))->ReadSentinel(1667434712)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNavigateByKey(std::move(aForward), std::move(aForDocumentNavigation));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_UIResolutionChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UIResolutionChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__dpi = IPC::ReadParam<float>((&(reader__)));
if (!maybe__dpi) {
FatalError("Error deserializing 'float'");
return MsgValueError;
}
auto& dpi = *maybe__dpi;
// Sentinel = 'dpi'
if ((!(((&(reader__)))->ReadSentinel(41419070)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'float'");
return MsgValueError;
}
auto maybe__rounding = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__rounding) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& rounding = *maybe__rounding;
// Sentinel = 'rounding'
if ((!(((&(reader__)))->ReadSentinel(261292903)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto maybe__scale = IPC::ReadParam<double>((&(reader__)));
if (!maybe__scale) {
FatalError("Error deserializing 'double'");
return MsgValueError;
}
auto& scale = *maybe__scale;
// Sentinel = 'scale'
if ((!(((&(reader__)))->ReadSentinel(103809545)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'double'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvUIResolutionChanged(std::move(dpi), std::move(rounding), std::move(scale));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SafeAreaInsetsChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SafeAreaInsetsChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aSafeAreaInsets = IPC::ReadParam<ScreenIntMargin>((&(reader__)));
if (!maybe__aSafeAreaInsets) {
FatalError("Error deserializing 'ScreenIntMargin'");
return MsgValueError;
}
auto& aSafeAreaInsets = *maybe__aSafeAreaInsets;
// Sentinel = 'aSafeAreaInsets'
if ((!(((&(reader__)))->ReadSentinel(752944592)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScreenIntMargin'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvSafeAreaInsetsChanged(std::move(aSafeAreaInsets));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SwappedWithOtherRemoteLoader__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SwappedWithOtherRemoteLoader", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__context = IPC::ReadParam<IPCTabContext>((&(reader__)));
if (!maybe__context) {
FatalError("Error deserializing 'IPCTabContext'");
return MsgValueError;
}
auto& context = *maybe__context;
// Sentinel = 'context'
if ((!(((&(reader__)))->ReadSentinel(199164678)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCTabContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvSwappedWithOtherRemoteLoader(std::move(context));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_HandleAccessKey__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_HandleAccessKey", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetKeyboardEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetKeyboardEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetKeyboardEvent'");
return MsgValueError;
}
auto maybe__charCodes = IPC::ReadParam<nsTArray<uint32_t>>((&(reader__)));
if (!maybe__charCodes) {
FatalError("Error deserializing 'uint32_t[]'");
return MsgValueError;
}
auto& charCodes = *maybe__charCodes;
// Sentinel = 'charCodes'
if ((!(((&(reader__)))->ReadSentinel(294323085)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvHandleAccessKey(std::move(event), std::move(charCodes));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_PrintPreview__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PrintPreview", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPrintData = IPC::ReadParam<PrintData>((&(reader__)));
if (!maybe__aPrintData) {
FatalError("Error deserializing 'PrintData'");
return MsgValueError;
}
auto& aPrintData = *maybe__aPrintData;
// Sentinel = 'aPrintData'
if ((!(((&(reader__)))->ReadSentinel(359072745)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PrintData'");
return MsgValueError;
}
auto maybe__aSourceBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aSourceBrowsingContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aSourceBrowsingContext = *maybe__aSourceBrowsingContext;
// Sentinel = 'aSourceBrowsingContext'
if ((!(((&(reader__)))->ReadSentinel(1709639939)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PBrowser::Reply_PrintPreview(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
PrintPreviewResolver resolver = [resolver__ = std::move(resolver__)](const PrintPreviewResultInfo& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'aInfo'
((&(writer__)))->WriteSentinel(93520366);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvPrintPreview(std::move(aPrintData), std::move(aSourceBrowsingContext), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_ExitPrintPreview__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ExitPrintPreview", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvExitPrintPreview();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_Print__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_Print", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aBC = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aBC) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aBC = *maybe__aBC;
// Sentinel = 'aBC'
if ((!(((&(reader__)))->ReadSentinel(32309479)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aPrintData = IPC::ReadParam<PrintData>((&(reader__)));
if (!maybe__aPrintData) {
FatalError("Error deserializing 'PrintData'");
return MsgValueError;
}
auto& aPrintData = *maybe__aPrintData;
// Sentinel = 'aPrintData'
if ((!(((&(reader__)))->ReadSentinel(359072745)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PrintData'");
return MsgValueError;
}
auto maybe__aReturnStaticClone = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aReturnStaticClone) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aReturnStaticClone = *maybe__aReturnStaticClone;
// Sentinel = 'aReturnStaticClone'
if ((!(((&(reader__)))->ReadSentinel(1151993659)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PBrowser::Reply_Print(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
PrintResolver resolver = [resolver__ = std::move(resolver__)](const MaybeDiscardedBrowsingContext& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'staticCloneBrowsingContext'
((&(writer__)))->WriteSentinel(2396719786);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvPrint(std::move(aBC), std::move(aPrintData), std::move(aReturnStaticClone), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_PrintClonedPage__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PrintClonedPage", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aBC = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aBC) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aBC = *maybe__aBC;
// Sentinel = 'aBC'
if ((!(((&(reader__)))->ReadSentinel(32309479)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aPrintData = IPC::ReadParam<PrintData>((&(reader__)));
if (!maybe__aPrintData) {
FatalError("Error deserializing 'PrintData'");
return MsgValueError;
}
auto& aPrintData = *maybe__aPrintData;
// Sentinel = 'aPrintData'
if ((!(((&(reader__)))->ReadSentinel(359072745)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PrintData'");
return MsgValueError;
}
auto maybe__aStaticCloneBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aStaticCloneBrowsingContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aStaticCloneBrowsingContext = *maybe__aStaticCloneBrowsingContext;
// Sentinel = 'aStaticCloneBrowsingContext'
if ((!(((&(reader__)))->ReadSentinel(2513898219)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvPrintClonedPage(std::move(aBC), std::move(aPrintData), std::move(aStaticCloneBrowsingContext));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_DestroyPrintClone__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DestroyPrintClone", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aStaticCloneBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aStaticCloneBrowsingContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aStaticCloneBrowsingContext = *maybe__aStaticCloneBrowsingContext;
// Sentinel = 'aStaticCloneBrowsingContext'
if ((!(((&(reader__)))->ReadSentinel(2513898219)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvDestroyPrintClone(std::move(aStaticCloneBrowsingContext));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_UpdateNativeWindowHandle__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateNativeWindowHandle", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aNewHandle = IPC::ReadParam<uintptr_t>((&(reader__)));
if (!maybe__aNewHandle) {
FatalError("Error deserializing 'uintptr_t'");
return MsgValueError;
}
auto& aNewHandle = *maybe__aNewHandle;
// Sentinel = 'aNewHandle'
if ((!(((&(reader__)))->ReadSentinel(347145176)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uintptr_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvUpdateNativeWindowHandle(std::move(aNewHandle));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_AllowScriptsToClose__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_AllowScriptsToClose", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvAllowScriptsToClose();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_WillChangeProcess__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_WillChangeProcess", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvWillChangeProcess();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Reply_IsWindowSupportingProtectedMedia__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_IsWindowSupportingProtectedMedia", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<bool> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__isSupported = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__isSupported) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& isSupported = *maybe__isSupported;
// Sentinel = 'isSupported'
if ((!(((&(reader__)))->ReadSentinel(466355363)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(isSupported));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PBrowser::Reply_IsWindowSupportingWebVR__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_IsWindowSupportingWebVR", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<bool> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__isSupported = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__isSupported) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& isSupported = *maybe__isSupported;
// Sentinel = 'isSupported'
if ((!(((&(reader__)))->ReadSentinel(466355363)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(isSupported));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PBrowser::Reply_PSessionStoreConstructor__ID:
{
return MsgProcessed;
}
default:
return MsgNotKnown;
}
}
auto PBrowserChild::OnMessageReceived(
const Message& msg__,
UniquePtr<Message>& reply__) -> PBrowserChild::Result
{
return MsgNotKnown;
}
auto PBrowserChild::DoomSubtree() -> void
{
for (auto* key : mManagedPColorPickerChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPDocAccessibleChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPFilePickerChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPPaymentRequestChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPSessionStoreChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPWindowGlobalChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPBrowserBridgeChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPVsyncChild) {
key->DoomSubtree();
}
SetDoomed();
}
auto PBrowserChild::PeekManagedActor() -> IProtocol*
{
if (IProtocol* actor = mManagedPColorPickerChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPDocAccessibleChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPFilePickerChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPPaymentRequestChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPSessionStoreChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPWindowGlobalChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPBrowserBridgeChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPVsyncChild.Peek()) {
return actor;
}
return nullptr;
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::PBrowserChild*>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
MOZ_RELEASE_ASSERT(
aWriter->GetActor(),
"Cannot serialize managed actors without an actor");
int32_t id;
if (!aVar) {
id = 0; // kNullActorId
} else {
id = aVar->Id();
if (id == 1) { // kFreedActorId
aVar->FatalError("Actor has been |delete|d");
}
MOZ_RELEASE_ASSERT(
aWriter->GetActor()->GetIPCChannel() == aVar->GetIPCChannel(),
"Actor must be from the same channel as the"
" actor it's being sent over");
MOZ_RELEASE_ASSERT(
aVar->CanSend(),
"Actor must still be open when sending");
}
IPC::WriteParam(aWriter, id);
}
auto ParamTraits<::mozilla::dom::PBrowserChild*>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
MOZ_RELEASE_ASSERT(
aReader->GetActor(),
"Cannot deserialize managed actors without an actor");
mozilla::Maybe<mozilla::ipc::IProtocol*> actor = aReader->GetActor()
->ReadActor(aReader, true, "PBrowser", PBrowserMsgStart);
if (actor.isSome()) {
return static_cast<::mozilla::dom::PBrowserChild*>(actor.ref());
}
return {};
}
} // namespace IPC