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

Copy as Markdown

Other Tools

//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/PBrowserParent.h"
#include "ipc/nsGUIEventIPC.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/LayoutMessageUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/RemoteLazyInputStream.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/BindingIPCUtils.h"
#include "mozilla/dom/BrowserParent.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/PColorPickerParent.h"
#include "mozilla/dom/PContentParent.h"
#include "mozilla/a11y/PDocAccessibleParent.h"
#include "mozilla/dom/PFilePickerParent.h"
#include "mozilla/layout/PRemotePrintJobParent.h"
#include "mozilla/dom/PPaymentRequestParent.h"
#include "mozilla/dom/PSessionStoreParent.h"
#include "mozilla/dom/PWindowGlobalParent.h"
#include "mozilla/dom/PBrowserBridgeParent.h"
#include "mozilla/dom/PVsyncParent.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 {
auto PBrowserParent::RecvPDocAccessibleConstructor(
PDocAccessibleParent* actor,
PDocAccessibleParent* aParentDoc,
const uint64_t& aParentAcc,
const MaybeDiscardedBrowsingContext& aBrowsingContext) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PBrowserParent::RecvPPaymentRequestConstructor(PPaymentRequestParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PBrowserParent::RecvPVsyncConstructor(PVsyncParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PBrowserParent::RecvPColorPickerConstructor(
PColorPickerParent* actor,
const nsAString& title,
const nsAString& initialColor,
nsTArray<nsString>&& defaultColors) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PBrowserParent::RecvPFilePickerConstructor(
PFilePickerParent* actor,
const nsAString& aTitle,
const Mode& aMode,
const MaybeDiscardedBrowsingContext& aBrowsingContext) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PBrowserParent::Recv__delete__() -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PBrowserParent::RecvPSessionStoreConstructor(PSessionStoreParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
MOZ_IMPLICIT PBrowserParent::PBrowserParent() :
mozilla::ipc::IRefCountedProtocol(PBrowserMsgStart, mozilla::ipc::ParentSide)
{
MOZ_COUNT_CTOR(PBrowserParent);
}
PBrowserParent::~PBrowserParent()
{
MOZ_COUNT_DTOR(PBrowserParent);
}
auto PBrowserParent::ActorAlloc() -> void
{
AddRef();
}
auto PBrowserParent::ActorDealloc() -> void
{
Release();
}
auto PBrowserParent::OtherPid() const -> ::base::ProcessId
{
::base::ProcessId pid =
::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherPidMaybeInvalid();
MOZ_RELEASE_ASSERT(pid != ::base::kInvalidProcessId);
return pid;
}
auto PBrowserParent::Manager() const -> PContentParent*
{
return static_cast<PContentParent*>(IProtocol::Manager());
}
auto PBrowserParent::ManagedPColorPickerParent(nsTArray<PColorPickerParent*>& aArr) const -> void
{
mManagedPColorPickerParent.ToArray(aArr);
}
auto PBrowserParent::ManagedPColorPickerParent() const -> const ManagedContainer<PColorPickerParent>&
{
return mManagedPColorPickerParent;
}
auto PBrowserParent::ManagedPDocAccessibleParent(nsTArray<PDocAccessibleParent*>& aArr) const -> void
{
mManagedPDocAccessibleParent.ToArray(aArr);
}
auto PBrowserParent::ManagedPDocAccessibleParent() const -> const ManagedContainer<PDocAccessibleParent>&
{
return mManagedPDocAccessibleParent;
}
auto PBrowserParent::ManagedPFilePickerParent(nsTArray<PFilePickerParent*>& aArr) const -> void
{
mManagedPFilePickerParent.ToArray(aArr);
}
auto PBrowserParent::ManagedPFilePickerParent() const -> const ManagedContainer<PFilePickerParent>&
{
return mManagedPFilePickerParent;
}
auto PBrowserParent::ManagedPPaymentRequestParent(nsTArray<PPaymentRequestParent*>& aArr) const -> void
{
mManagedPPaymentRequestParent.ToArray(aArr);
}
auto PBrowserParent::ManagedPPaymentRequestParent() const -> const ManagedContainer<PPaymentRequestParent>&
{
return mManagedPPaymentRequestParent;
}
auto PBrowserParent::ManagedPSessionStoreParent(nsTArray<PSessionStoreParent*>& aArr) const -> void
{
mManagedPSessionStoreParent.ToArray(aArr);
}
auto PBrowserParent::ManagedPSessionStoreParent() const -> const ManagedContainer<PSessionStoreParent>&
{
return mManagedPSessionStoreParent;
}
auto PBrowserParent::ManagedPWindowGlobalParent(nsTArray<PWindowGlobalParent*>& aArr) const -> void
{
mManagedPWindowGlobalParent.ToArray(aArr);
}
auto PBrowserParent::ManagedPWindowGlobalParent() const -> const ManagedContainer<PWindowGlobalParent>&
{
return mManagedPWindowGlobalParent;
}
auto PBrowserParent::ManagedPBrowserBridgeParent(nsTArray<PBrowserBridgeParent*>& aArr) const -> void
{
mManagedPBrowserBridgeParent.ToArray(aArr);
}
auto PBrowserParent::ManagedPBrowserBridgeParent() const -> const ManagedContainer<PBrowserBridgeParent>&
{
return mManagedPBrowserBridgeParent;
}
auto PBrowserParent::ManagedPVsyncParent(nsTArray<PVsyncParent*>& aArr) const -> void
{
mManagedPVsyncParent.ToArray(aArr);
}
auto PBrowserParent::ManagedPVsyncParent() const -> const ManagedContainer<PVsyncParent>&
{
return mManagedPVsyncParent;
}
auto PBrowserParent::AllManagedActors(nsTArray<RefPtr<mozilla::ipc::ActorLifecycleProxy>>& arr__) const -> void
{
uint32_t total = 0;
total += mManagedPColorPickerParent.Count();
total += mManagedPDocAccessibleParent.Count();
total += mManagedPFilePickerParent.Count();
total += mManagedPPaymentRequestParent.Count();
total += mManagedPSessionStoreParent.Count();
total += mManagedPWindowGlobalParent.Count();
total += mManagedPBrowserBridgeParent.Count();
total += mManagedPVsyncParent.Count();
arr__.SetCapacity(total);
for (auto* key : mManagedPColorPickerParent) {
arr__.AppendElement(key->GetLifecycleProxy());
}
for (auto* key : mManagedPDocAccessibleParent) {
arr__.AppendElement(key->GetLifecycleProxy());
}
for (auto* key : mManagedPFilePickerParent) {
arr__.AppendElement(key->GetLifecycleProxy());
}
for (auto* key : mManagedPPaymentRequestParent) {
arr__.AppendElement(key->GetLifecycleProxy());
}
for (auto* key : mManagedPSessionStoreParent) {
arr__.AppendElement(key->GetLifecycleProxy());
}
for (auto* key : mManagedPWindowGlobalParent) {
arr__.AppendElement(key->GetLifecycleProxy());
}
for (auto* key : mManagedPBrowserBridgeParent) {
arr__.AppendElement(key->GetLifecycleProxy());
}
for (auto* key : mManagedPVsyncParent) {
arr__.AppendElement(key->GetLifecycleProxy());
}
}
auto PBrowserParent::AllManagedActorsCount() const -> uint32_t
{
uint32_t total = 0;
total += mManagedPColorPickerParent.Count();
total += mManagedPDocAccessibleParent.Count();
total += mManagedPFilePickerParent.Count();
total += mManagedPPaymentRequestParent.Count();
total += mManagedPSessionStoreParent.Count();
total += mManagedPWindowGlobalParent.Count();
total += mManagedPBrowserBridgeParent.Count();
total += mManagedPVsyncParent.Count();
return total;
}
auto PBrowserParent::OpenPColorPickerEndpoint(PColorPickerParent* aActor) -> ManagedEndpoint<PColorPickerChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PColorPickerParent actor");
return ManagedEndpoint<PColorPickerChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPColorPickerParent.Insert(aActor);
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PColorPickerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserParent::BindPColorPickerEndpoint(
ManagedEndpoint<PColorPickerParent> aEndpoint,
PColorPickerParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPColorPickerParent);
}
auto PBrowserParent::OpenPDocAccessibleEndpoint(PDocAccessibleParent* aActor) -> ManagedEndpoint<PDocAccessibleChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PDocAccessibleParent actor");
return ManagedEndpoint<PDocAccessibleChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPDocAccessibleParent.Insert(aActor);
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PDocAccessibleChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserParent::BindPDocAccessibleEndpoint(
ManagedEndpoint<PDocAccessibleParent> aEndpoint,
PDocAccessibleParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPDocAccessibleParent);
}
auto PBrowserParent::OpenPFilePickerEndpoint(PFilePickerParent* aActor) -> ManagedEndpoint<PFilePickerChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PFilePickerParent actor");
return ManagedEndpoint<PFilePickerChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPFilePickerParent.Insert(aActor);
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PFilePickerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserParent::BindPFilePickerEndpoint(
ManagedEndpoint<PFilePickerParent> aEndpoint,
PFilePickerParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPFilePickerParent);
}
auto PBrowserParent::OpenPPaymentRequestEndpoint(PPaymentRequestParent* aActor) -> ManagedEndpoint<PPaymentRequestChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PPaymentRequestParent actor");
return ManagedEndpoint<PPaymentRequestChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPPaymentRequestParent.Insert(aActor);
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PPaymentRequestChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserParent::BindPPaymentRequestEndpoint(
ManagedEndpoint<PPaymentRequestParent> aEndpoint,
PPaymentRequestParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPPaymentRequestParent);
}
auto PBrowserParent::OpenPSessionStoreEndpoint(PSessionStoreParent* aActor) -> ManagedEndpoint<PSessionStoreChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PSessionStoreParent actor");
return ManagedEndpoint<PSessionStoreChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPSessionStoreParent.Insert(aActor);
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PSessionStoreChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserParent::BindPSessionStoreEndpoint(
ManagedEndpoint<PSessionStoreParent> aEndpoint,
PSessionStoreParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPSessionStoreParent);
}
auto PBrowserParent::OpenPWindowGlobalEndpoint(PWindowGlobalParent* aActor) -> ManagedEndpoint<PWindowGlobalChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWindowGlobalParent actor");
return ManagedEndpoint<PWindowGlobalChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPWindowGlobalParent.Insert(aActor);
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PWindowGlobalChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserParent::BindPWindowGlobalEndpoint(
ManagedEndpoint<PWindowGlobalParent> aEndpoint,
PWindowGlobalParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPWindowGlobalParent);
}
auto PBrowserParent::OpenPBrowserBridgeEndpoint(PBrowserBridgeParent* aActor) -> ManagedEndpoint<PBrowserBridgeChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBrowserBridgeParent actor");
return ManagedEndpoint<PBrowserBridgeChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPBrowserBridgeParent.Insert(aActor);
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PBrowserBridgeChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserParent::BindPBrowserBridgeEndpoint(
ManagedEndpoint<PBrowserBridgeParent> aEndpoint,
PBrowserBridgeParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPBrowserBridgeParent);
}
auto PBrowserParent::OpenPVsyncEndpoint(PVsyncParent* aActor) -> ManagedEndpoint<PVsyncChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PVsyncParent actor");
return ManagedEndpoint<PVsyncChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPVsyncParent.Insert(aActor);
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PVsyncChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBrowserParent::BindPVsyncEndpoint(
ManagedEndpoint<PVsyncParent> aEndpoint,
PVsyncParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPVsyncParent);
}
auto PBrowserParent::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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
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 PBrowserParent::SendNativeSynthesisResponse(
const uint64_t& aObserverId,
const nsACString& aResponse) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NativeSynthesisResponse(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aObserverId);
// Sentinel = 'aObserverId'
((&(writer__)))->WriteSentinel(435356759);
IPC::WriteParam((&(writer__)), aResponse);
// Sentinel = 'aResponse'
((&(writer__)))->WriteSentinel(301466545);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NativeSynthesisResponse", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendUpdateSHistory() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateSHistory(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateSHistory", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendCloneDocumentTreeIntoSelf(
const MaybeDiscardedBrowsingContext& aBc,
const PrintData& aPrintData,
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_CloneDocumentTreeIntoSelf(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aBc);
// Sentinel = 'aBc'
((&(writer__)))->WriteSentinel(34406663);
IPC::WriteParam((&(writer__)), aPrintData);
// Sentinel = 'aPrintData'
((&(writer__)))->WriteSentinel(359072745);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_CloneDocumentTreeIntoSelf", OTHER);
ChannelSend(std::move(msg__), PBrowser::Reply_CloneDocumentTreeIntoSelf__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PBrowserParent::SendCloneDocumentTreeIntoSelf(
const MaybeDiscardedBrowsingContext& aBc,
const PrintData& aPrintData) -> RefPtr<CloneDocumentTreeIntoSelfPromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendCloneDocumentTreeIntoSelf(std::move(aBc), std::move(aPrintData), [promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PBrowserParent::SendUpdateRemotePrintSettings(const PrintData& aPrintData) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateRemotePrintSettings(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPrintData);
// Sentinel = 'aPrintData'
((&(writer__)))->WriteSentinel(359072745);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateRemotePrintSettings", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendReleaseAllPointerCapture() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ReleaseAllPointerCapture(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ReleaseAllPointerCapture", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendUpdateEffects(const EffectsInfo& aEffects) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateEffects(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEffects);
// Sentinel = 'aEffects'
((&(writer__)))->WriteSentinel(225248034);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateEffects", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendShow(
const ParentShowInfo& parentInfo,
const OwnerShowInfo& childInfo) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_Show(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), parentInfo);
// Sentinel = 'parentInfo'
((&(writer__)))->WriteSentinel(380044311);
IPC::WriteParam((&(writer__)), childInfo);
// Sentinel = 'childInfo'
((&(writer__)))->WriteSentinel(298320785);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_Show", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendActivate(const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_Activate(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_Activate", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendDeactivate(const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_Deactivate(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_Deactivate", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendScrollbarPreferenceChanged(const ScrollbarPreference& pref) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ScrollbarPreferenceChanged(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), pref);
// Sentinel = 'pref'
((&(writer__)))->WriteSentinel(71958958);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ScrollbarPreferenceChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendInitRendering(
const TextureFactoryIdentifier& textureFactoryIdentifier,
const LayersId& layersId,
const CompositorOptions& compositorOptions,
const bool& layersConnected) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_InitRendering(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), textureFactoryIdentifier);
// Sentinel = 'textureFactoryIdentifier'
((&(writer__)))->WriteSentinel(2096630253);
IPC::WriteParam((&(writer__)), layersId);
// Sentinel = 'layersId'
((&(writer__)))->WriteSentinel(250938174);
IPC::WriteParam((&(writer__)), compositorOptions);
// Sentinel = 'compositorOptions'
((&(writer__)))->WriteSentinel(1089275708);
IPC::WriteParam((&(writer__)), layersConnected);
// Sentinel = 'layersConnected'
((&(writer__)))->WriteSentinel(829294116);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_InitRendering", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendCompositorOptionsChanged(const CompositorOptions& newOptions) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_CompositorOptionsChanged(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), newOptions);
// Sentinel = 'newOptions'
((&(writer__)))->WriteSentinel(384304183);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_CompositorOptionsChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendLoadURL(
mozilla::NotNull<nsDocShellLoadState*> loadState,
const ParentShowInfo& info) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_LoadURL(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), loadState);
// Sentinel = 'loadState'
((&(writer__)))->WriteSentinel(304808866);
IPC::WriteParam((&(writer__)), info);
// Sentinel = 'info'
((&(writer__)))->WriteSentinel(70058413);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_LoadURL", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendCreateAboutBlankDocumentViewer(
nsIPrincipal* principal,
nsIPrincipal* partitionedPrincipal) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_CreateAboutBlankDocumentViewer(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
IPC::WriteParam((&(writer__)), partitionedPrincipal);
// Sentinel = 'partitionedPrincipal'
((&(writer__)))->WriteSentinel(1472661574);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_CreateAboutBlankDocumentViewer", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendResumeLoad(
const uint64_t& pendingSwitchID,
const ParentShowInfo& info) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ResumeLoad(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), pendingSwitchID);
// Sentinel = 'pendingSwitchID'
((&(writer__)))->WriteSentinel(822478309);
IPC::WriteParam((&(writer__)), info);
// Sentinel = 'info'
((&(writer__)))->WriteSentinel(70058413);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ResumeLoad", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendUpdateDimensions(const DimensionInfo& dimensions) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateDimensions(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), dimensions);
// Sentinel = 'dimensions'
((&(writer__)))->WriteSentinel(383845434);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateDimensions", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendSizeModeChanged(const nsSizeMode& sizeMode) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SizeModeChanged(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), sizeMode);
// Sentinel = 'sizeMode'
((&(writer__)))->WriteSentinel(251790145);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SizeModeChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendChildToParentMatrix(
const mozilla::Maybe<Matrix4x4>& aMatrix,
const ScreenRect& aRemoteDocumentRect) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ChildToParentMatrix(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aMatrix);
// Sentinel = 'aMatrix'
((&(writer__)))->WriteSentinel(181469911);
IPC::WriteParam((&(writer__)), aRemoteDocumentRect);
// Sentinel = 'aRemoteDocumentRect'
((&(writer__)))->WriteSentinel(1261242267);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ChildToParentMatrix", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendUpdateRemoteStyle(const StyleImageRendering& aImageRendering) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateRemoteStyle(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aImageRendering);
// Sentinel = 'aImageRendering'
((&(writer__)))->WriteSentinel(768804323);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateRemoteStyle", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendDynamicToolbarMaxHeightChanged(const ScreenIntCoord& height) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DynamicToolbarMaxHeightChanged(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), height);
// Sentinel = 'height'
((&(writer__)))->WriteSentinel(143393402);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DynamicToolbarMaxHeightChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendDynamicToolbarOffsetChanged(const ScreenIntCoord& height) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DynamicToolbarOffsetChanged(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), height);
// Sentinel = 'height'
((&(writer__)))->WriteSentinel(143393402);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DynamicToolbarOffsetChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendStopIMEStateManagement() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_StopIMEStateManagement(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_StopIMEStateManagement", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendRealMouseMoveEvent(
const WidgetMouseEvent& event,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealMouseMoveEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealMouseMoveEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNormalPriorityRealMouseMoveEvent(
const WidgetMouseEvent& event,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealMouseMoveEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealMouseMoveEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendRealMouseMoveEventForTests(
const WidgetMouseEvent& event,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealMouseMoveEventForTests(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealMouseMoveEventForTests", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNormalPriorityRealMouseMoveEventForTests(
const WidgetMouseEvent& event,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealMouseMoveEventForTests(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealMouseMoveEventForTests", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendSynthMouseMoveEvent(
const WidgetMouseEvent& event,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthMouseMoveEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthMouseMoveEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNormalPrioritySynthMouseMoveEvent(
const WidgetMouseEvent& event,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPrioritySynthMouseMoveEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPrioritySynthMouseMoveEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendRealMouseButtonEvent(
const WidgetMouseEvent& event,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealMouseButtonEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealMouseButtonEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNormalPriorityRealMouseButtonEvent(
const WidgetMouseEvent& event,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealMouseButtonEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealMouseButtonEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendRealMouseEnterExitWidgetEvent(
const WidgetMouseEvent& event,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealMouseEnterExitWidgetEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealMouseEnterExitWidgetEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNormalPriorityRealMouseEnterExitWidgetEvent(
const WidgetMouseEvent& event,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealMouseEnterExitWidgetEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealMouseEnterExitWidgetEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendRealKeyEvent(
const WidgetKeyboardEvent& aEvent,
const nsID& aUUID) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealKeyEvent(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealKeyEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNormalPriorityRealKeyEvent(
const WidgetKeyboardEvent& aEvent,
const nsID& aUUID) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealKeyEvent(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealKeyEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendMouseWheelEvent(
const WidgetWheelEvent& event,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_MouseWheelEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_MouseWheelEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNormalPriorityMouseWheelEvent(
const WidgetWheelEvent& event,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityMouseWheelEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityMouseWheelEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendRealTouchEvent(
const WidgetTouchEvent& aEvent,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId,
const nsEventStatus& aApzResponse) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealTouchEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEvent);
// Sentinel = 'aEvent'
((&(writer__)))->WriteSentinel(133956196);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
IPC::WriteParam((&(writer__)), aApzResponse);
// Sentinel = 'aApzResponse'
((&(writer__)))->WriteSentinel(512951516);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealTouchEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNormalPriorityRealTouchEvent(
const WidgetTouchEvent& aEvent,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId,
const nsEventStatus& aApzResponse) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealTouchEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEvent);
// Sentinel = 'aEvent'
((&(writer__)))->WriteSentinel(133956196);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
IPC::WriteParam((&(writer__)), aApzResponse);
// Sentinel = 'aApzResponse'
((&(writer__)))->WriteSentinel(512951516);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealTouchEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendHandleTap(
const GeckoContentController_TapType& aType,
const LayoutDevicePoint& point,
const Modifiers& aModifiers,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId,
const mozilla::Maybe<DoubleTapToZoomMetrics>& aMetrics) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_HandleTap(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aType);
// Sentinel = 'aType'
((&(writer__)))->WriteSentinel(99222020);
IPC::WriteParam((&(writer__)), point);
// Sentinel = 'point'
((&(writer__)))->WriteSentinel(108790315);
IPC::WriteParam((&(writer__)), aModifiers);
// Sentinel = 'aModifiers'
((&(writer__)))->WriteSentinel(358286340);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
IPC::WriteParam((&(writer__)), aMetrics);
// Sentinel = 'aMetrics'
((&(writer__)))->WriteSentinel(235471673);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_HandleTap", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNormalPriorityHandleTap(
const GeckoContentController_TapType& aType,
const LayoutDevicePoint& point,
const Modifiers& aModifiers,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId,
const mozilla::Maybe<DoubleTapToZoomMetrics>& aMetrics) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityHandleTap(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aType);
// Sentinel = 'aType'
((&(writer__)))->WriteSentinel(99222020);
IPC::WriteParam((&(writer__)), point);
// Sentinel = 'point'
((&(writer__)))->WriteSentinel(108790315);
IPC::WriteParam((&(writer__)), aModifiers);
// Sentinel = 'aModifiers'
((&(writer__)))->WriteSentinel(358286340);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
IPC::WriteParam((&(writer__)), aMetrics);
// Sentinel = 'aMetrics'
((&(writer__)))->WriteSentinel(235471673);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityHandleTap", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendRealTouchMoveEvent(
const WidgetTouchEvent& aEvent,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId,
const nsEventStatus& aApzResponse) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealTouchMoveEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEvent);
// Sentinel = 'aEvent'
((&(writer__)))->WriteSentinel(133956196);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
IPC::WriteParam((&(writer__)), aApzResponse);
// Sentinel = 'aApzResponse'
((&(writer__)))->WriteSentinel(512951516);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealTouchMoveEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNormalPriorityRealTouchMoveEvent(
const WidgetTouchEvent& aEvent,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId,
const nsEventStatus& aApzResponse) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealTouchMoveEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEvent);
// Sentinel = 'aEvent'
((&(writer__)))->WriteSentinel(133956196);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
IPC::WriteParam((&(writer__)), aApzResponse);
// Sentinel = 'aApzResponse'
((&(writer__)))->WriteSentinel(512951516);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealTouchMoveEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendRealTouchMoveEvent2(
const WidgetTouchEvent& aEvent,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId,
const nsEventStatus& aApzResponse) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealTouchMoveEvent2(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEvent);
// Sentinel = 'aEvent'
((&(writer__)))->WriteSentinel(133956196);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
IPC::WriteParam((&(writer__)), aApzResponse);
// Sentinel = 'aApzResponse'
((&(writer__)))->WriteSentinel(512951516);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealTouchMoveEvent2", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNormalPriorityRealTouchMoveEvent2(
const WidgetTouchEvent& aEvent,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId,
const nsEventStatus& aApzResponse) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealTouchMoveEvent2(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEvent);
// Sentinel = 'aEvent'
((&(writer__)))->WriteSentinel(133956196);
IPC::WriteParam((&(writer__)), aGuid);
// Sentinel = 'aGuid'
((&(writer__)))->WriteSentinel(94044651);
IPC::WriteParam((&(writer__)), aInputBlockId);
// Sentinel = 'aInputBlockId'
((&(writer__)))->WriteSentinel(595657994);
IPC::WriteParam((&(writer__)), aApzResponse);
// Sentinel = 'aApzResponse'
((&(writer__)))->WriteSentinel(512951516);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealTouchMoveEvent2", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendRealDragEvent(
const WidgetDragEvent& aEvent,
const uint32_t& aDragAction,
const uint32_t& aDropEffect,
nsIPrincipal* aPrincipal,
nsIContentSecurityPolicy* csp) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealDragEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEvent);
// Sentinel = 'aEvent'
((&(writer__)))->WriteSentinel(133956196);
IPC::WriteParam((&(writer__)), aDragAction);
// Sentinel = 'aDragAction'
((&(writer__)))->WriteSentinel(411370558);
IPC::WriteParam((&(writer__)), aDropEffect);
// Sentinel = 'aDropEffect'
((&(writer__)))->WriteSentinel(419759172);
IPC::WriteParam((&(writer__)), aPrincipal);
// Sentinel = 'aPrincipal'
((&(writer__)))->WriteSentinel(364381188);
IPC::WriteParam((&(writer__)), csp);
// Sentinel = 'csp'
((&(writer__)))->WriteSentinel(42074439);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RealDragEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendCompositionEvent(const WidgetCompositionEvent& event) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_CompositionEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_CompositionEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNormalPriorityCompositionEvent(const WidgetCompositionEvent& event) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityCompositionEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityCompositionEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendSelectionEvent(const WidgetSelectionEvent& event) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SelectionEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SelectionEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNormalPrioritySelectionEvent(const WidgetSelectionEvent& event) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPrioritySelectionEvent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPrioritySelectionEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendInsertText(const nsAString& aStringToInsert) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_InsertText(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aStringToInsert);
// Sentinel = 'aStringToInsert'
((&(writer__)))->WriteSentinel(801768977);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_InsertText", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNormalPriorityInsertText(const nsAString& aStringToInsert) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityInsertText(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aStringToInsert);
// Sentinel = 'aStringToInsert'
((&(writer__)))->WriteSentinel(801768977);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityInsertText", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendPasteTransferable(IPCTransferable&& aTransferable) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_PasteTransferable(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), std::move(aTransferable));
// Sentinel = 'aTransferable'
((&(writer__)))->WriteSentinel(609813819);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PasteTransferable", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendLoadRemoteScript(
const nsAString& aURL,
const bool& aRunInGlobalScope) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_LoadRemoteScript(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aURL);
// Sentinel = 'aURL'
((&(writer__)))->WriteSentinel(58130773);
IPC::WriteParam((&(writer__)), aRunInGlobalScope);
// Sentinel = 'aRunInGlobalScope'
((&(writer__)))->WriteSentinel(981862041);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_LoadRemoteScript", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendDestroy() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_Destroy(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_Destroy", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendRenderLayers(const bool& aEnabled) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RenderLayers(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEnabled);
// Sentinel = 'aEnabled'
((&(writer__)))->WriteSentinel(224789261);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RenderLayers", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendPreserveLayers(const bool& aPreserve) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_PreserveLayers(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPreserve);
// Sentinel = 'aPreserve'
((&(writer__)))->WriteSentinel(300417966);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PreserveLayers", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendSuppressDisplayport(const bool& aEnabled) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SuppressDisplayport(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEnabled);
// Sentinel = 'aEnabled'
((&(writer__)))->WriteSentinel(224789261);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SuppressDisplayport", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendNavigateByKey(
const bool& aForward,
const bool& aForDocumentNavigation) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NavigateByKey(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aForward);
// Sentinel = 'aForward'
((&(writer__)))->WriteSentinel(236258103);
IPC::WriteParam((&(writer__)), aForDocumentNavigation);
// Sentinel = 'aForDocumentNavigation'
((&(writer__)))->WriteSentinel(1667434712);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NavigateByKey", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendUIResolutionChanged(
const float& dpi,
const int32_t& rounding,
const double& scale) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UIResolutionChanged(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), dpi);
// Sentinel = 'dpi'
((&(writer__)))->WriteSentinel(41419070);
IPC::WriteParam((&(writer__)), rounding);
// Sentinel = 'rounding'
((&(writer__)))->WriteSentinel(261292903);
IPC::WriteParam((&(writer__)), scale);
// Sentinel = 'scale'
((&(writer__)))->WriteSentinel(103809545);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UIResolutionChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendSafeAreaInsetsChanged(const ScreenIntMargin& aSafeAreaInsets) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SafeAreaInsetsChanged(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aSafeAreaInsets);
// Sentinel = 'aSafeAreaInsets'
((&(writer__)))->WriteSentinel(752944592);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SafeAreaInsetsChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendSwappedWithOtherRemoteLoader(const IPCTabContext& context) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SwappedWithOtherRemoteLoader(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), context);
// Sentinel = 'context'
((&(writer__)))->WriteSentinel(199164678);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SwappedWithOtherRemoteLoader", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendHandleAccessKey(
const WidgetKeyboardEvent& event,
mozilla::Span<uint32_t const> charCodes) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_HandleAccessKey(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
IPC::WriteParam((&(writer__)), charCodes);
// Sentinel = 'charCodes'
((&(writer__)))->WriteSentinel(294323085);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_HandleAccessKey", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendPrintPreview(
const PrintData& aPrintData,
const MaybeDiscardedBrowsingContext& aSourceBrowsingContext,
mozilla::ipc::ResolveCallback<PrintPreviewResultInfo>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_PrintPreview(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPrintData);
// Sentinel = 'aPrintData'
((&(writer__)))->WriteSentinel(359072745);
IPC::WriteParam((&(writer__)), aSourceBrowsingContext);
// Sentinel = 'aSourceBrowsingContext'
((&(writer__)))->WriteSentinel(1709639939);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PrintPreview", OTHER);
ChannelSend(std::move(msg__), PBrowser::Reply_PrintPreview__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PBrowserParent::SendPrintPreview(
const PrintData& aPrintData,
const MaybeDiscardedBrowsingContext& aSourceBrowsingContext) -> RefPtr<PrintPreviewPromise>
{
RefPtr<MozPromise<PrintPreviewResultInfo, ResponseRejectReason, true>::Private> promise__ = new MozPromise<PrintPreviewResultInfo, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendPrintPreview(std::move(aPrintData), std::move(aSourceBrowsingContext), [promise__](PrintPreviewResultInfo&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PBrowserParent::SendExitPrintPreview() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ExitPrintPreview(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ExitPrintPreview", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendPrint(
const MaybeDiscardedBrowsingContext& aBC,
const PrintData& aPrintData,
const bool& aReturnStaticClone,
mozilla::ipc::ResolveCallback<MaybeDiscardedBrowsingContext>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_Print(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aBC);
// Sentinel = 'aBC'
((&(writer__)))->WriteSentinel(32309479);
IPC::WriteParam((&(writer__)), aPrintData);
// Sentinel = 'aPrintData'
((&(writer__)))->WriteSentinel(359072745);
IPC::WriteParam((&(writer__)), aReturnStaticClone);
// Sentinel = 'aReturnStaticClone'
((&(writer__)))->WriteSentinel(1151993659);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_Print", OTHER);
ChannelSend(std::move(msg__), PBrowser::Reply_Print__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PBrowserParent::SendPrint(
const MaybeDiscardedBrowsingContext& aBC,
const PrintData& aPrintData,
const bool& aReturnStaticClone) -> RefPtr<PrintPromise>
{
RefPtr<MozPromise<MaybeDiscardedBrowsingContext, ResponseRejectReason, true>::Private> promise__ = new MozPromise<MaybeDiscardedBrowsingContext, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendPrint(std::move(aBC), std::move(aPrintData), std::move(aReturnStaticClone), [promise__](MaybeDiscardedBrowsingContext&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PBrowserParent::SendPrintClonedPage(
const MaybeDiscardedBrowsingContext& aBC,
const PrintData& aPrintData,
const MaybeDiscardedBrowsingContext& aStaticCloneBrowsingContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_PrintClonedPage(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aBC);
// Sentinel = 'aBC'
((&(writer__)))->WriteSentinel(32309479);
IPC::WriteParam((&(writer__)), aPrintData);
// Sentinel = 'aPrintData'
((&(writer__)))->WriteSentinel(359072745);
IPC::WriteParam((&(writer__)), aStaticCloneBrowsingContext);
// Sentinel = 'aStaticCloneBrowsingContext'
((&(writer__)))->WriteSentinel(2513898219);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PrintClonedPage", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendDestroyPrintClone(const MaybeDiscardedBrowsingContext& aStaticCloneBrowsingContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DestroyPrintClone(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aStaticCloneBrowsingContext);
// Sentinel = 'aStaticCloneBrowsingContext'
((&(writer__)))->WriteSentinel(2513898219);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DestroyPrintClone", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendUpdateNativeWindowHandle(const uintptr_t& aNewHandle) -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateNativeWindowHandle(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aNewHandle);
// Sentinel = 'aNewHandle'
((&(writer__)))->WriteSentinel(347145176);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateNativeWindowHandle", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendAllowScriptsToClose() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_AllowScriptsToClose(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_AllowScriptsToClose", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::SendWillChangeProcess() -> bool
{
UniquePtr<IPC::Message> msg__ = PBrowser::Msg_WillChangeProcess(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_WillChangeProcess", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PBrowserParent::RemoveManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
switch (aProtocolId) {
case PColorPickerMsgStart:
{
PColorPickerParent* actor = static_cast<PColorPickerParent*>(aListener);
const bool removed = mManagedPColorPickerParent.EnsureRemoved(actor);
MOZ_RELEASE_ASSERT(removed, "actor not managed by this!");
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PDocAccessibleMsgStart:
{
PDocAccessibleParent* actor = static_cast<PDocAccessibleParent*>(aListener);
const bool removed = mManagedPDocAccessibleParent.EnsureRemoved(actor);
MOZ_RELEASE_ASSERT(removed, "actor not managed by this!");
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PFilePickerMsgStart:
{
PFilePickerParent* actor = static_cast<PFilePickerParent*>(aListener);
const bool removed = mManagedPFilePickerParent.EnsureRemoved(actor);
MOZ_RELEASE_ASSERT(removed, "actor not managed by this!");
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PPaymentRequestMsgStart:
{
PPaymentRequestParent* actor = static_cast<PPaymentRequestParent*>(aListener);
const bool removed = mManagedPPaymentRequestParent.EnsureRemoved(actor);
MOZ_RELEASE_ASSERT(removed, "actor not managed by this!");
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PSessionStoreMsgStart:
{
PSessionStoreParent* actor = static_cast<PSessionStoreParent*>(aListener);
const bool removed = mManagedPSessionStoreParent.EnsureRemoved(actor);
MOZ_RELEASE_ASSERT(removed, "actor not managed by this!");
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PWindowGlobalMsgStart:
{
PWindowGlobalParent* actor = static_cast<PWindowGlobalParent*>(aListener);
const bool removed = mManagedPWindowGlobalParent.EnsureRemoved(actor);
MOZ_RELEASE_ASSERT(removed, "actor not managed by this!");
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PBrowserBridgeMsgStart:
{
PBrowserBridgeParent* actor = static_cast<PBrowserBridgeParent*>(aListener);
const bool removed = mManagedPBrowserBridgeParent.EnsureRemoved(actor);
MOZ_RELEASE_ASSERT(removed, "actor not managed by this!");
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PVsyncMsgStart:
{
PVsyncParent* actor = static_cast<PVsyncParent*>(aListener);
const bool removed = mManagedPVsyncParent.EnsureRemoved(actor);
MOZ_RELEASE_ASSERT(removed, "actor not managed by this!");
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} default:
FatalError("unreached");
return; }
}
auto PBrowserParent::DeallocManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
switch (aProtocolId) {
case PDocAccessibleMsgStart:
static_cast<BrowserParent*>(this)->DeallocPDocAccessibleParent(static_cast<PDocAccessibleParent*>(aListener));
return;
case PPaymentRequestMsgStart:
static_cast<BrowserParent*>(this)->DeallocPPaymentRequestParent(static_cast<PPaymentRequestParent*>(aListener));
return;
default:
FatalError("unreached");
return;
}
}
auto PBrowserParent::OnMessageReceived(const Message& msg__) -> PBrowserParent::Result
{
switch (msg__.type()) {
case MANAGED_ENDPOINT_BOUND_MESSAGE_TYPE:
{
if (!mAwaitingManagedEndpointBind) {
NS_WARNING("Unexpected managed endpoint lifecycle message after actor bound!");
return MsgNotAllowed;
}
mAwaitingManagedEndpointBind = false;
return MsgProcessed;
}
case MANAGED_ENDPOINT_DROPPED_MESSAGE_TYPE:
{
if (!mAwaitingManagedEndpointBind) {
NS_WARNING("Unexpected managed endpoint lifecycle message after actor bound!");
return MsgNotAllowed;
}
mAwaitingManagedEndpointBind = false;
IProtocol* mgr = this->Manager();
this->DestroySubtree(ManagedEndpointDropped);
this->ClearSubtree();
mgr->RemoveManagee(PBrowserMsgStart, this);
return MsgProcessed;
}
case PBrowser::Msg_AsyncMessage__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
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<BrowserParent*>(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::Msg_PDocAccessibleConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PDocAccessibleConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto maybe__aParentDoc = IPC::ReadParam<PDocAccessibleParent*>((&(reader__)));
if (!maybe__aParentDoc) {
FatalError("Error deserializing 'PDocAccessible'");
return MsgValueError;
}
auto& aParentDoc = *maybe__aParentDoc;
// Sentinel = 'aParentDoc'
if ((!(((&(reader__)))->ReadSentinel(355140578)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PDocAccessible'");
return MsgValueError;
}
auto maybe__aParentAcc = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aParentAcc) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aParentAcc = *maybe__aParentAcc;
// Sentinel = 'aParentAcc'
if ((!(((&(reader__)))->ReadSentinel(352977875)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aBrowsingContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aBrowsingContext = *maybe__aBrowsingContext;
// Sentinel = 'aBrowsingContext'
if ((!(((&(reader__)))->ReadSentinel(915015314)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
PDocAccessibleParent* actor = (static_cast<BrowserParent*>(this))->AllocPDocAccessibleParent(aParentDoc, aParentAcc, aBrowsingContext);
if (!actor) {
NS_WARNING("Cannot bind null PDocAccessibleParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPDocAccessibleParent.Insert(actor);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvPDocAccessibleConstructor(std::move(actor), std::move(aParentDoc), std::move(aParentAcc), std::move(aBrowsingContext));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_PPaymentRequestConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PPaymentRequestConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
PPaymentRequestParent* actor = (static_cast<BrowserParent*>(this))->AllocPPaymentRequestParent();
if (!actor) {
NS_WARNING("Cannot bind null PPaymentRequestParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPPaymentRequestParent.Insert(actor);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvPPaymentRequestConstructor(std::move(actor));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_PVsyncConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PVsyncConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PVsyncParent> actor = (static_cast<BrowserParent*>(this))->AllocPVsyncParent();
if (!actor) {
NS_WARNING("Cannot bind null PVsyncParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPVsyncParent.Insert(actor);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvPVsyncConstructor(actor);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_DidUnsuppressPainting__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DidUnsuppressPainting", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvDidUnsuppressPainting();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_DidUnsuppressPaintingNormalPriority__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DidUnsuppressPaintingNormalPriority", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvDidUnsuppressPaintingNormalPriority();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_MoveFocus__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_MoveFocus", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__forward = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__forward) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& forward = *maybe__forward;
// Sentinel = 'forward'
if ((!(((&(reader__)))->ReadSentinel(200016630)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__forDocumentNavigation = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__forDocumentNavigation) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& forDocumentNavigation = *maybe__forDocumentNavigation;
// Sentinel = 'forDocumentNavigation'
if ((!(((&(reader__)))->ReadSentinel(1571555479)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvMoveFocus(std::move(forward), std::move(forDocumentNavigation));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_DropLinks__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DropLinks", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aLinks = IPC::ReadParam<nsTArray<nsString>>((&(reader__)));
if (!maybe__aLinks) {
FatalError("Error deserializing 'nsString[]'");
return MsgValueError;
}
auto& aLinks = *maybe__aLinks;
// Sentinel = 'aLinks'
if ((!(((&(reader__)))->ReadSentinel(134152803)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvDropLinks(std::move(aLinks));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NotifyIMEFocus__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMEFocus", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__contentCache = IPC::ReadParam<ContentCache>((&(reader__)));
if (!maybe__contentCache) {
FatalError("Error deserializing 'ContentCache'");
return MsgValueError;
}
auto& contentCache = *maybe__contentCache;
// Sentinel = 'contentCache'
if ((!(((&(reader__)))->ReadSentinel(535299280)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ContentCache'");
return MsgValueError;
}
auto maybe__notification = IPC::ReadParam<IMENotification>((&(reader__)));
if (!maybe__notification) {
FatalError("Error deserializing 'IMENotification'");
return MsgValueError;
}
auto& notification = *maybe__notification;
// Sentinel = 'notification'
if ((!(((&(reader__)))->ReadSentinel(550438152)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IMENotification'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PBrowser::Reply_NotifyIMEFocus(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
NotifyIMEFocusResolver resolver = [resolver__ = std::move(resolver__)](const IMENotificationRequests& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'requests'
((&(writer__)))->WriteSentinel(261227389);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNotifyIMEFocus(std::move(contentCache), std::move(notification), 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_NotifyIMETextChange__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMETextChange", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__contentCache = IPC::ReadParam<ContentCache>((&(reader__)));
if (!maybe__contentCache) {
FatalError("Error deserializing 'ContentCache'");
return MsgValueError;
}
auto& contentCache = *maybe__contentCache;
// Sentinel = 'contentCache'
if ((!(((&(reader__)))->ReadSentinel(535299280)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ContentCache'");
return MsgValueError;
}
auto maybe__notification = IPC::ReadParam<IMENotification>((&(reader__)));
if (!maybe__notification) {
FatalError("Error deserializing 'IMENotification'");
return MsgValueError;
}
auto& notification = *maybe__notification;
// Sentinel = 'notification'
if ((!(((&(reader__)))->ReadSentinel(550438152)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IMENotification'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNotifyIMETextChange(std::move(contentCache), std::move(notification));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NotifyIMECompositionUpdate__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMECompositionUpdate", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__contentCache = IPC::ReadParam<ContentCache>((&(reader__)));
if (!maybe__contentCache) {
FatalError("Error deserializing 'ContentCache'");
return MsgValueError;
}
auto& contentCache = *maybe__contentCache;
// Sentinel = 'contentCache'
if ((!(((&(reader__)))->ReadSentinel(535299280)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ContentCache'");
return MsgValueError;
}
auto maybe__notification = IPC::ReadParam<IMENotification>((&(reader__)));
if (!maybe__notification) {
FatalError("Error deserializing 'IMENotification'");
return MsgValueError;
}
auto& notification = *maybe__notification;
// Sentinel = 'notification'
if ((!(((&(reader__)))->ReadSentinel(550438152)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IMENotification'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNotifyIMECompositionUpdate(std::move(contentCache), std::move(notification));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NotifyIMESelection__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMESelection", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__contentCache = IPC::ReadParam<ContentCache>((&(reader__)));
if (!maybe__contentCache) {
FatalError("Error deserializing 'ContentCache'");
return MsgValueError;
}
auto& contentCache = *maybe__contentCache;
// Sentinel = 'contentCache'
if ((!(((&(reader__)))->ReadSentinel(535299280)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ContentCache'");
return MsgValueError;
}
auto maybe__notification = IPC::ReadParam<IMENotification>((&(reader__)));
if (!maybe__notification) {
FatalError("Error deserializing 'IMENotification'");
return MsgValueError;
}
auto& notification = *maybe__notification;
// Sentinel = 'notification'
if ((!(((&(reader__)))->ReadSentinel(550438152)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IMENotification'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNotifyIMESelection(std::move(contentCache), std::move(notification));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_UpdateContentCache__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateContentCache", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__contentCache = IPC::ReadParam<ContentCache>((&(reader__)));
if (!maybe__contentCache) {
FatalError("Error deserializing 'ContentCache'");
return MsgValueError;
}
auto& contentCache = *maybe__contentCache;
// Sentinel = 'contentCache'
if ((!(((&(reader__)))->ReadSentinel(535299280)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ContentCache'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvUpdateContentCache(std::move(contentCache));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NotifyIMEPositionChange__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMEPositionChange", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__contentCache = IPC::ReadParam<ContentCache>((&(reader__)));
if (!maybe__contentCache) {
FatalError("Error deserializing 'ContentCache'");
return MsgValueError;
}
auto& contentCache = *maybe__contentCache;
// Sentinel = 'contentCache'
if ((!(((&(reader__)))->ReadSentinel(535299280)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ContentCache'");
return MsgValueError;
}
auto maybe__notification = IPC::ReadParam<IMENotification>((&(reader__)));
if (!maybe__notification) {
FatalError("Error deserializing 'IMENotification'");
return MsgValueError;
}
auto& notification = *maybe__notification;
// Sentinel = 'notification'
if ((!(((&(reader__)))->ReadSentinel(550438152)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IMENotification'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNotifyIMEPositionChange(std::move(contentCache), std::move(notification));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_OnEventNeedingAckHandled__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_OnEventNeedingAckHandled", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__message = IPC::ReadParam<EventMessage>((&(reader__)));
if (!maybe__message) {
FatalError("Error deserializing 'EventMessage'");
return MsgValueError;
}
auto& message = *maybe__message;
// Sentinel = 'message'
if ((!(((&(reader__)))->ReadSentinel(197198566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'EventMessage'");
return MsgValueError;
}
auto maybe__compositionId = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__compositionId) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& compositionId = *maybe__compositionId;
// Sentinel = 'compositionId'
if ((!(((&(reader__)))->ReadSentinel(645268834)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvOnEventNeedingAckHandled(std::move(message), std::move(compositionId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_RequestFocus__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RequestFocus", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__canRaise = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__canRaise) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& canRaise = *maybe__canRaise;
// Sentinel = 'canRaise'
if ((!(((&(reader__)))->ReadSentinel(234816295)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aCallerType = IPC::ReadParam<CallerType>((&(reader__)));
if (!maybe__aCallerType) {
FatalError("Error deserializing 'CallerType'");
return MsgValueError;
}
auto& aCallerType = *maybe__aCallerType;
// Sentinel = 'aCallerType'
if ((!(((&(reader__)))->ReadSentinel(422118487)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CallerType'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvRequestFocus(std::move(canRaise), std::move(aCallerType));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_WheelZoomChange__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_WheelZoomChange", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__increase = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__increase) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& increase = *maybe__increase;
// Sentinel = 'increase'
if ((!(((&(reader__)))->ReadSentinel(249561931)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvWheelZoomChange(std::move(increase));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_EnableDisableCommands__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_EnableDisableCommands", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__bc = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__bc) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& bc = *maybe__bc;
// Sentinel = 'bc'
if ((!(((&(reader__)))->ReadSentinel(19464390)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__action = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__action) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& action = *maybe__action;
// Sentinel = 'action'
if ((!(((&(reader__)))->ReadSentinel(143786623)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__enabledCommands = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
if (!maybe__enabledCommands) {
FatalError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto& enabledCommands = *maybe__enabledCommands;
// Sentinel = 'enabledCommands'
if ((!(((&(reader__)))->ReadSentinel(796263934)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto maybe__disabledCommands = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
if (!maybe__disabledCommands) {
FatalError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto& disabledCommands = *maybe__disabledCommands;
// Sentinel = 'disabledCommands'
if ((!(((&(reader__)))->ReadSentinel(909706859)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvEnableDisableCommands(std::move(bc), std::move(action), std::move(enabledCommands), std::move(disabledCommands));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SetInputContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SetInputContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__context = IPC::ReadParam<InputContext>((&(reader__)));
if (!maybe__context) {
FatalError("Error deserializing 'InputContext'");
return MsgValueError;
}
auto& context = *maybe__context;
// Sentinel = 'context'
if ((!(((&(reader__)))->ReadSentinel(199164678)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'InputContext'");
return MsgValueError;
}
auto maybe__action = IPC::ReadParam<InputContextAction>((&(reader__)));
if (!maybe__action) {
FatalError("Error deserializing 'InputContextAction'");
return MsgValueError;
}
auto& action = *maybe__action;
// Sentinel = 'action'
if ((!(((&(reader__)))->ReadSentinel(143786623)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'InputContextAction'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSetInputContext(std::move(context), std::move(action));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SetCursor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SetCursor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__value = IPC::ReadParam<nsCursor>((&(reader__)));
if (!maybe__value) {
FatalError("Error deserializing 'nsCursor'");
return MsgValueError;
}
auto& value = *maybe__value;
// Sentinel = 'value'
if ((!(((&(reader__)))->ReadSentinel(107610654)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCursor'");
return MsgValueError;
}
auto maybe__hasCustomCursor = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__hasCustomCursor) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& hasCustomCursor = *maybe__hasCustomCursor;
// Sentinel = 'hasCustomCursor'
if ((!(((&(reader__)))->ReadSentinel(818415158)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__customCursorData = IPC::ReadParam<mozilla::Maybe<BigBuffer>>((&(reader__)));
if (!maybe__customCursorData) {
FatalError("Error deserializing 'BigBuffer?'");
return MsgValueError;
}
auto& customCursorData = *maybe__customCursorData;
// Sentinel = 'customCursorData'
if ((!(((&(reader__)))->ReadSentinel(954992276)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'BigBuffer?'");
return MsgValueError;
}
auto maybe__width = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__width) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& width = *maybe__width;
// Sentinel = 'width'
if ((!(((&(reader__)))->ReadSentinel(108528161)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__height = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__height) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& height = *maybe__height;
// Sentinel = 'height'
if ((!(((&(reader__)))->ReadSentinel(143393402)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__resolutionX = IPC::ReadParam<float>((&(reader__)));
if (!maybe__resolutionX) {
FatalError("Error deserializing 'float'");
return MsgValueError;
}
auto& resolutionX = *maybe__resolutionX;
// Sentinel = 'resolutionX'
if ((!(((&(reader__)))->ReadSentinel(478217389)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'float'");
return MsgValueError;
}
auto maybe__resolutionY = IPC::ReadParam<float>((&(reader__)));
if (!maybe__resolutionY) {
FatalError("Error deserializing 'float'");
return MsgValueError;
}
auto& resolutionY = *maybe__resolutionY;
// Sentinel = 'resolutionY'
if ((!(((&(reader__)))->ReadSentinel(478282926)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'float'");
return MsgValueError;
}
auto maybe__stride = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__stride) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& stride = *maybe__stride;
// Sentinel = 'stride'
if ((!(((&(reader__)))->ReadSentinel(153879180)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__format = IPC::ReadParam<SurfaceFormat>((&(reader__)));
if (!maybe__format) {
FatalError("Error deserializing 'SurfaceFormat'");
return MsgValueError;
}
auto& format = *maybe__format;
// Sentinel = 'format'
if ((!(((&(reader__)))->ReadSentinel(148505226)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SurfaceFormat'");
return MsgValueError;
}
auto maybe__hotspotX = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__hotspotX) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& hotspotX = *maybe__hotspotX;
// Sentinel = 'hotspotX'
if ((!(((&(reader__)))->ReadSentinel(261423978)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__hotspotY = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__hotspotY) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& hotspotY = *maybe__hotspotY;
// Sentinel = 'hotspotY'
if ((!(((&(reader__)))->ReadSentinel(261489515)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__force = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__force) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& force = *maybe__force;
// Sentinel = 'force'
if ((!(((&(reader__)))->ReadSentinel(104858128)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSetCursor(std::move(value), std::move(hasCustomCursor), std::move(customCursorData), std::move(width), std::move(height), std::move(resolutionX), std::move(resolutionY), std::move(stride), std::move(format), std::move(hotspotX), std::move(hotspotY), std::move(force));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SetLinkStatus__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SetLinkStatus", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__status = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__status) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& status = *maybe__status;
// Sentinel = 'status'
if ((!(((&(reader__)))->ReadSentinel(154731173)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSetLinkStatus(std::move(status));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_ShowTooltip__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ShowTooltip", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__x = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__x) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& x = *maybe__x;
// Sentinel = 'x'
if ((!(((&(reader__)))->ReadSentinel(7929977)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__y = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__y) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& y = *maybe__y;
// Sentinel = 'y'
if ((!(((&(reader__)))->ReadSentinel(7995514)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__tooltip = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__tooltip) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& tooltip = *maybe__tooltip;
// Sentinel = 'tooltip'
if ((!(((&(reader__)))->ReadSentinel(205914892)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__direction = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__direction) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& direction = *maybe__direction;
// Sentinel = 'direction'
if ((!(((&(reader__)))->ReadSentinel(311886786)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvShowTooltip(std::move(x), std::move(y), std::move(tooltip), std::move(direction));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_HideTooltip__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_HideTooltip", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvHideTooltip();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_PColorPickerConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PColorPickerConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto maybe__title = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__title) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& title = *maybe__title;
// Sentinel = 'title'
if ((!(((&(reader__)))->ReadSentinel(109445667)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__initialColor = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__initialColor) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& initialColor = *maybe__initialColor;
// Sentinel = 'initialColor'
if ((!(((&(reader__)))->ReadSentinel(536216810)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__defaultColors = IPC::ReadParam<nsTArray<nsString>>((&(reader__)));
if (!maybe__defaultColors) {
FatalError("Error deserializing 'nsString[]'");
return MsgValueError;
}
auto& defaultColors = *maybe__defaultColors;
// Sentinel = 'defaultColors'
if ((!(((&(reader__)))->ReadSentinel(616760664)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString[]'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PColorPickerParent> actor = (static_cast<BrowserParent*>(this))->AllocPColorPickerParent(title, initialColor, defaultColors);
if (!actor) {
NS_WARNING("Cannot bind null PColorPickerParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPColorPickerParent.Insert(actor);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvPColorPickerConstructor(actor, std::move(title), std::move(initialColor), std::move(defaultColors));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_PFilePickerConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PFilePickerConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto maybe__aTitle = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aTitle) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aTitle = *maybe__aTitle;
// Sentinel = 'aTitle'
if ((!(((&(reader__)))->ReadSentinel(137167460)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aMode = IPC::ReadParam<Mode>((&(reader__)));
if (!maybe__aMode) {
FatalError("Error deserializing 'Mode'");
return MsgValueError;
}
auto& aMode = *maybe__aMode;
// Sentinel = 'aMode'
if ((!(((&(reader__)))->ReadSentinel(93848039)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Mode'");
return MsgValueError;
}
auto maybe__aBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aBrowsingContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aBrowsingContext = *maybe__aBrowsingContext;
// Sentinel = 'aBrowsingContext'
if ((!(((&(reader__)))->ReadSentinel(915015314)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PFilePickerParent> actor = (static_cast<BrowserParent*>(this))->AllocPFilePickerParent(aTitle, aMode, aBrowsingContext);
if (!actor) {
NS_WARNING("Cannot bind null PFilePickerParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPFilePickerParent.Insert(actor);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvPFilePickerConstructor(actor, std::move(aTitle), std::move(aMode), std::move(aBrowsingContext));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_RespondStartSwipeEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RespondStartSwipeEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
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__aStartSwipe = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aStartSwipe) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aStartSwipe = *maybe__aStartSwipe;
// Sentinel = 'aStartSwipe'
if ((!(((&(reader__)))->ReadSentinel(442565752)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvRespondStartSwipeEvent(std::move(aInputBlockId), std::move(aStartSwipe));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_LookUpDictionary__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_LookUpDictionary", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aText = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aText) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aText = *maybe__aText;
// Sentinel = 'aText'
if ((!(((&(reader__)))->ReadSentinel(97321479)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aFontRangeArray = IPC::ReadParam<nsTArray<FontRange>>((&(reader__)));
if (!maybe__aFontRangeArray) {
FatalError("Error deserializing 'FontRange[]'");
return MsgValueError;
}
auto& aFontRangeArray = *maybe__aFontRangeArray;
// Sentinel = 'aFontRangeArray'
if ((!(((&(reader__)))->ReadSentinel(775095781)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FontRange[]'");
return MsgValueError;
}
auto maybe__aIsVertical = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aIsVertical) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aIsVertical = *maybe__aIsVertical;
// Sentinel = 'aIsVertical'
if ((!(((&(reader__)))->ReadSentinel(427361368)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aPoint = IPC::ReadParam<LayoutDeviceIntPoint>((&(reader__)));
if (!maybe__aPoint) {
FatalError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto& aPoint = *maybe__aPoint;
// Sentinel = 'aPoint'
if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvLookUpDictionary(std::move(aText), std::move(aFontRangeArray), std::move(aIsVertical), std::move(aPoint));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg___delete____ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg___delete__", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->Recv__delete__();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
IProtocol* mgr = this->Manager();
this->DestroySubtree(Deletion);
this->ClearSubtree();
mgr->RemoveManagee(PBrowserMsgStart, this);
return MsgProcessed;
}
case PBrowser::Msg_ReplyKeyEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ReplyKeyEvent", 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<BrowserParent*>(this))->RecvReplyKeyEvent(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_SynthesizeNativeKeyEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeKeyEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aNativeKeyboardLayout = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aNativeKeyboardLayout) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aNativeKeyboardLayout = *maybe__aNativeKeyboardLayout;
// Sentinel = 'aNativeKeyboardLayout'
if ((!(((&(reader__)))->ReadSentinel(1529153656)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto maybe__aNativeKeyCode = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aNativeKeyCode) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aNativeKeyCode = *maybe__aNativeKeyCode;
// Sentinel = 'aNativeKeyCode'
if ((!(((&(reader__)))->ReadSentinel(680527213)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto maybe__aModifierFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aModifierFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aModifierFlags = *maybe__aModifierFlags;
// Sentinel = 'aModifierFlags'
if ((!(((&(reader__)))->ReadSentinel(681444734)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aCharacters = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aCharacters) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aCharacters = *maybe__aCharacters;
// Sentinel = 'aCharacters'
if ((!(((&(reader__)))->ReadSentinel(422380642)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aUnmodifiedCharacters = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aUnmodifiedCharacters) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aUnmodifiedCharacters = *maybe__aUnmodifiedCharacters;
// Sentinel = 'aUnmodifiedCharacters'
if ((!(((&(reader__)))->ReadSentinel(1529874534)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
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;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeKeyEvent(std::move(aNativeKeyboardLayout), std::move(aNativeKeyCode), std::move(aModifierFlags), std::move(aCharacters), std::move(aUnmodifiedCharacters), std::move(aObserverId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SynthesizeNativeMouseEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeMouseEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPoint = IPC::ReadParam<LayoutDeviceIntPoint>((&(reader__)));
if (!maybe__aPoint) {
FatalError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto& aPoint = *maybe__aPoint;
// Sentinel = 'aPoint'
if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto maybe__aNativeMessage = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aNativeMessage) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aNativeMessage = *maybe__aNativeMessage;
// Sentinel = 'aNativeMessage'
if ((!(((&(reader__)))->ReadSentinel(689702286)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aButton = IPC::ReadParam<int16_t>((&(reader__)));
if (!maybe__aButton) {
FatalError("Error deserializing 'int16_t'");
return MsgValueError;
}
auto& aButton = *maybe__aButton;
// Sentinel = 'aButton'
if ((!(((&(reader__)))->ReadSentinel(184222430)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int16_t'");
return MsgValueError;
}
auto maybe__aModifierFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aModifierFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aModifierFlags = *maybe__aModifierFlags;
// Sentinel = 'aModifierFlags'
if ((!(((&(reader__)))->ReadSentinel(681444734)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
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;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeMouseEvent(std::move(aPoint), std::move(aNativeMessage), std::move(aButton), std::move(aModifierFlags), std::move(aObserverId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SynthesizeNativeMouseMove__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeMouseMove", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPoint = IPC::ReadParam<LayoutDeviceIntPoint>((&(reader__)));
if (!maybe__aPoint) {
FatalError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto& aPoint = *maybe__aPoint;
// Sentinel = 'aPoint'
if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
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;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeMouseMove(std::move(aPoint), std::move(aObserverId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SynthesizeNativeMouseScrollEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeMouseScrollEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPoint = IPC::ReadParam<LayoutDeviceIntPoint>((&(reader__)));
if (!maybe__aPoint) {
FatalError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto& aPoint = *maybe__aPoint;
// Sentinel = 'aPoint'
if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto maybe__aNativeMessage = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aNativeMessage) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aNativeMessage = *maybe__aNativeMessage;
// Sentinel = 'aNativeMessage'
if ((!(((&(reader__)))->ReadSentinel(689702286)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aDeltaX = IPC::ReadParam<double>((&(reader__)));
if (!maybe__aDeltaX) {
FatalError("Error deserializing 'double'");
return MsgValueError;
}
auto& aDeltaX = *maybe__aDeltaX;
// Sentinel = 'aDeltaX'
if ((!(((&(reader__)))->ReadSentinel(174391972)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'double'");
return MsgValueError;
}
auto maybe__aDeltaY = IPC::ReadParam<double>((&(reader__)));
if (!maybe__aDeltaY) {
FatalError("Error deserializing 'double'");
return MsgValueError;
}
auto& aDeltaY = *maybe__aDeltaY;
// Sentinel = 'aDeltaY'
if ((!(((&(reader__)))->ReadSentinel(174457509)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'double'");
return MsgValueError;
}
auto maybe__aDeltaZ = IPC::ReadParam<double>((&(reader__)));
if (!maybe__aDeltaZ) {
FatalError("Error deserializing 'double'");
return MsgValueError;
}
auto& aDeltaZ = *maybe__aDeltaZ;
// Sentinel = 'aDeltaZ'
if ((!(((&(reader__)))->ReadSentinel(174523046)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'double'");
return MsgValueError;
}
auto maybe__aModifierFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aModifierFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aModifierFlags = *maybe__aModifierFlags;
// Sentinel = 'aModifierFlags'
if ((!(((&(reader__)))->ReadSentinel(681444734)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aAdditionalFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aAdditionalFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aAdditionalFlags = *maybe__aAdditionalFlags;
// Sentinel = 'aAdditionalFlags'
if ((!(((&(reader__)))->ReadSentinel(880084552)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
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;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeMouseScrollEvent(std::move(aPoint), std::move(aNativeMessage), std::move(aDeltaX), std::move(aDeltaY), std::move(aDeltaZ), std::move(aModifierFlags), std::move(aAdditionalFlags), std::move(aObserverId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SynthesizeNativeTouchPoint__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchPoint", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPointerId = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aPointerId) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aPointerId = *maybe__aPointerId;
// Sentinel = 'aPointerId'
if ((!(((&(reader__)))->ReadSentinel(364053488)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aPointerState = IPC::ReadParam<TouchPointerState>((&(reader__)));
if (!maybe__aPointerState) {
FatalError("Error deserializing 'TouchPointerState'");
return MsgValueError;
}
auto& aPointerState = *maybe__aPointerState;
// Sentinel = 'aPointerState'
if ((!(((&(reader__)))->ReadSentinel(610600260)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TouchPointerState'");
return MsgValueError;
}
auto maybe__aPoint = IPC::ReadParam<LayoutDeviceIntPoint>((&(reader__)));
if (!maybe__aPoint) {
FatalError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto& aPoint = *maybe__aPoint;
// Sentinel = 'aPoint'
if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto maybe__aPointerPressure = IPC::ReadParam<double>((&(reader__)));
if (!maybe__aPointerPressure) {
FatalError("Error deserializing 'double'");
return MsgValueError;
}
auto& aPointerPressure = *maybe__aPointerPressure;
// Sentinel = 'aPointerPressure'
if ((!(((&(reader__)))->ReadSentinel(922617500)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'double'");
return MsgValueError;
}
auto maybe__aPointerOrientation = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aPointerOrientation) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aPointerOrientation = *maybe__aPointerOrientation;
// Sentinel = 'aPointerOrientation'
if ((!(((&(reader__)))->ReadSentinel(1287653327)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
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;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeTouchPoint(std::move(aPointerId), std::move(aPointerState), std::move(aPoint), std::move(aPointerPressure), std::move(aPointerOrientation), std::move(aObserverId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SynthesizeNativeTouchPadPinch__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchPadPinch", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEventPhase = IPC::ReadParam<TouchpadGesturePhase>((&(reader__)));
if (!maybe__aEventPhase) {
FatalError("Error deserializing 'TouchpadGesturePhase'");
return MsgValueError;
}
auto& aEventPhase = *maybe__aEventPhase;
// Sentinel = 'aEventPhase'
if ((!(((&(reader__)))->ReadSentinel(428737621)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TouchpadGesturePhase'");
return MsgValueError;
}
auto maybe__aScale = IPC::ReadParam<float>((&(reader__)));
if (!maybe__aScale) {
FatalError("Error deserializing 'float'");
return MsgValueError;
}
auto& aScale = *maybe__aScale;
// Sentinel = 'aScale'
if ((!(((&(reader__)))->ReadSentinel(131531338)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'float'");
return MsgValueError;
}
auto maybe__aPoint = IPC::ReadParam<LayoutDeviceIntPoint>((&(reader__)));
if (!maybe__aPoint) {
FatalError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto& aPoint = *maybe__aPoint;
// Sentinel = 'aPoint'
if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto maybe__aModifierFlags = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aModifierFlags) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aModifierFlags = *maybe__aModifierFlags;
// Sentinel = 'aModifierFlags'
if ((!(((&(reader__)))->ReadSentinel(681444734)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeTouchPadPinch(std::move(aEventPhase), std::move(aScale), std::move(aPoint), std::move(aModifierFlags));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SynthesizeNativeTouchTap__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchTap", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPoint = IPC::ReadParam<LayoutDeviceIntPoint>((&(reader__)));
if (!maybe__aPoint) {
FatalError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto& aPoint = *maybe__aPoint;
// Sentinel = 'aPoint'
if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto maybe__aLongTap = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aLongTap) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aLongTap = *maybe__aLongTap;
// Sentinel = 'aLongTap'
if ((!(((&(reader__)))->ReadSentinel(229507863)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
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;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeTouchTap(std::move(aPoint), std::move(aLongTap), std::move(aObserverId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_ClearNativeTouchSequence__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ClearNativeTouchSequence", 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;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvClearNativeTouchSequence(std::move(aObserverId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SynthesizeNativePenInput__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativePenInput", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPointerId = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aPointerId) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aPointerId = *maybe__aPointerId;
// Sentinel = 'aPointerId'
if ((!(((&(reader__)))->ReadSentinel(364053488)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aPointerState = IPC::ReadParam<TouchPointerState>((&(reader__)));
if (!maybe__aPointerState) {
FatalError("Error deserializing 'TouchPointerState'");
return MsgValueError;
}
auto& aPointerState = *maybe__aPointerState;
// Sentinel = 'aPointerState'
if ((!(((&(reader__)))->ReadSentinel(610600260)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TouchPointerState'");
return MsgValueError;
}
auto maybe__aPoint = IPC::ReadParam<LayoutDeviceIntPoint>((&(reader__)));
if (!maybe__aPoint) {
FatalError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto& aPoint = *maybe__aPoint;
// Sentinel = 'aPoint'
if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto maybe__aPressure = IPC::ReadParam<double>((&(reader__)));
if (!maybe__aPressure) {
FatalError("Error deserializing 'double'");
return MsgValueError;
}
auto& aPressure = *maybe__aPressure;
// Sentinel = 'aPressure'
if ((!(((&(reader__)))->ReadSentinel(304153531)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'double'");
return MsgValueError;
}
auto maybe__aRotation = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aRotation) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aRotation = *maybe__aRotation;
// Sentinel = 'aRotation'
if ((!(((&(reader__)))->ReadSentinel(301925298)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aTiltX = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aTiltX) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aTiltX = *maybe__aTiltX;
// Sentinel = 'aTiltX'
if ((!(((&(reader__)))->ReadSentinel(135791191)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto maybe__aTiltY = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aTiltY) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aTiltY = *maybe__aTiltY;
// Sentinel = 'aTiltY'
if ((!(((&(reader__)))->ReadSentinel(135856728)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto maybe__aButton = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aButton) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aButton = *maybe__aButton;
// Sentinel = 'aButton'
if ((!(((&(reader__)))->ReadSentinel(184222430)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
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;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativePenInput(std::move(aPointerId), std::move(aPointerState), std::move(aPoint), std::move(aPressure), std::move(aRotation), std::move(aTiltX), std::move(aTiltY), std::move(aButton), std::move(aObserverId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SynthesizeNativeTouchpadDoubleTap__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchpadDoubleTap", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPoint = IPC::ReadParam<LayoutDeviceIntPoint>((&(reader__)));
if (!maybe__aPoint) {
FatalError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto& aPoint = *maybe__aPoint;
// Sentinel = 'aPoint'
if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto maybe__aModifierFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aModifierFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aModifierFlags = *maybe__aModifierFlags;
// Sentinel = 'aModifierFlags'
if ((!(((&(reader__)))->ReadSentinel(681444734)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeTouchpadDoubleTap(std::move(aPoint), std::move(aModifierFlags));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SynthesizeNativeTouchpadPan__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchpadPan", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEventPhase = IPC::ReadParam<TouchpadGesturePhase>((&(reader__)));
if (!maybe__aEventPhase) {
FatalError("Error deserializing 'TouchpadGesturePhase'");
return MsgValueError;
}
auto& aEventPhase = *maybe__aEventPhase;
// Sentinel = 'aEventPhase'
if ((!(((&(reader__)))->ReadSentinel(428737621)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TouchpadGesturePhase'");
return MsgValueError;
}
auto maybe__aPoint = IPC::ReadParam<LayoutDeviceIntPoint>((&(reader__)));
if (!maybe__aPoint) {
FatalError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto& aPoint = *maybe__aPoint;
// Sentinel = 'aPoint'
if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
return MsgValueError;
}
auto maybe__aDeltaX = IPC::ReadParam<double>((&(reader__)));
if (!maybe__aDeltaX) {
FatalError("Error deserializing 'double'");
return MsgValueError;
}
auto& aDeltaX = *maybe__aDeltaX;
// Sentinel = 'aDeltaX'
if ((!(((&(reader__)))->ReadSentinel(174391972)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'double'");
return MsgValueError;
}
auto maybe__aDeltaY = IPC::ReadParam<double>((&(reader__)));
if (!maybe__aDeltaY) {
FatalError("Error deserializing 'double'");
return MsgValueError;
}
auto& aDeltaY = *maybe__aDeltaY;
// Sentinel = 'aDeltaY'
if ((!(((&(reader__)))->ReadSentinel(174457509)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'double'");
return MsgValueError;
}
auto maybe__aModifierFlags = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aModifierFlags) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aModifierFlags = *maybe__aModifierFlags;
// Sentinel = 'aModifierFlags'
if ((!(((&(reader__)))->ReadSentinel(681444734)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
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;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeTouchpadPan(std::move(aEventPhase), std::move(aPoint), std::move(aDeltaX), std::move(aDeltaY), std::move(aModifierFlags), std::move(aObserverId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_LockNativePointer__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_LockNativePointer", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvLockNativePointer();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_UnlockNativePointer__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_UnlockNativePointer", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvUnlockNativePointer();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_AccessKeyNotHandled__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_AccessKeyNotHandled", 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;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvAccessKeyNotHandled(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_RegisterProtocolHandler__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RegisterProtocolHandler", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__scheme = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__scheme) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& scheme = *maybe__scheme;
// Sentinel = 'scheme'
if ((!(((&(reader__)))->ReadSentinel(146080374)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__handlerURI = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__handlerURI) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& handlerURI = *maybe__handlerURI;
// Sentinel = 'handlerURI'
if ((!(((&(reader__)))->ReadSentinel(367264719)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__title = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__title) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& title = *maybe__title;
// Sentinel = 'title'
if ((!(((&(reader__)))->ReadSentinel(109445667)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__documentURI = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__documentURI) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& documentURI = *maybe__documentURI;
// Sentinel = 'documentURI'
if ((!(((&(reader__)))->ReadSentinel(453706832)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvRegisterProtocolHandler(std::move(scheme), handlerURI, std::move(title), documentURI);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_OnStateChange__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_OnStateChange", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aWebProgressData = IPC::ReadParam<WebProgressData>((&(reader__)));
if (!maybe__aWebProgressData) {
FatalError("Error deserializing 'WebProgressData'");
return MsgValueError;
}
auto& aWebProgressData = *maybe__aWebProgressData;
// Sentinel = 'aWebProgressData'
if ((!(((&(reader__)))->ReadSentinel(890504783)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WebProgressData'");
return MsgValueError;
}
auto maybe__aRequestData = IPC::ReadParam<RequestData>((&(reader__)));
if (!maybe__aRequestData) {
FatalError("Error deserializing 'RequestData'");
return MsgValueError;
}
auto& aRequestData = *maybe__aRequestData;
// Sentinel = 'aRequestData'
if ((!(((&(reader__)))->ReadSentinel(518390981)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'RequestData'");
return MsgValueError;
}
auto maybe__aStateFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aStateFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aStateFlags = *maybe__aStateFlags;
// Sentinel = 'aStateFlags'
if ((!(((&(reader__)))->ReadSentinel(428606544)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aStatus = IPC::ReadParam<nsresult>((&(reader__)));
if (!maybe__aStatus) {
FatalError("Error deserializing 'nsresult'");
return MsgValueError;
}
auto& aStatus = *maybe__aStatus;
// Sentinel = 'aStatus'
if ((!(((&(reader__)))->ReadSentinel(186712806)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
return MsgValueError;
}
auto maybe__aStateChangeData = IPC::ReadParam<mozilla::Maybe<WebProgressStateChangeData>>((&(reader__)));
if (!maybe__aStateChangeData) {
FatalError("Error deserializing 'WebProgressStateChangeData?'");
return MsgValueError;
}
auto& aStateChangeData = *maybe__aStateChangeData;
// Sentinel = 'aStateChangeData'
if ((!(((&(reader__)))->ReadSentinel(876086819)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WebProgressStateChangeData?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvOnStateChange(std::move(aWebProgressData), std::move(aRequestData), std::move(aStateFlags), std::move(aStatus), std::move(aStateChangeData));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_OnLocationChange__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_OnLocationChange", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aWebProgressData = IPC::ReadParam<WebProgressData>((&(reader__)));
if (!maybe__aWebProgressData) {
FatalError("Error deserializing 'WebProgressData'");
return MsgValueError;
}
auto& aWebProgressData = *maybe__aWebProgressData;
// Sentinel = 'aWebProgressData'
if ((!(((&(reader__)))->ReadSentinel(890504783)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WebProgressData'");
return MsgValueError;
}
auto maybe__aRequestData = IPC::ReadParam<RequestData>((&(reader__)));
if (!maybe__aRequestData) {
FatalError("Error deserializing 'RequestData'");
return MsgValueError;
}
auto& aRequestData = *maybe__aRequestData;
// Sentinel = 'aRequestData'
if ((!(((&(reader__)))->ReadSentinel(518390981)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'RequestData'");
return MsgValueError;
}
auto maybe__aLocation = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__aLocation) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& aLocation = *maybe__aLocation;
// Sentinel = 'aLocation'
if ((!(((&(reader__)))->ReadSentinel(292094875)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__aFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aFlags = *maybe__aFlags;
// Sentinel = 'aFlags'
if ((!(((&(reader__)))->ReadSentinel(129892943)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aCanGoBack = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aCanGoBack) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aCanGoBack = *maybe__aCanGoBack;
// Sentinel = 'aCanGoBack'
if ((!(((&(reader__)))->ReadSentinel(325714843)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aCanGoForward = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aCanGoForward) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aCanGoForward = *maybe__aCanGoForward;
// Sentinel = 'aCanGoForward'
if ((!(((&(reader__)))->ReadSentinel(563152127)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aLocationChangeData = IPC::ReadParam<mozilla::Maybe<WebProgressLocationChangeData>>((&(reader__)));
if (!maybe__aLocationChangeData) {
FatalError("Error deserializing 'WebProgressLocationChangeData?'");
return MsgValueError;
}
auto& aLocationChangeData = *maybe__aLocationChangeData;
// Sentinel = 'aLocationChangeData'
if ((!(((&(reader__)))->ReadSentinel(1235617627)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WebProgressLocationChangeData?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvOnLocationChange(std::move(aWebProgressData), std::move(aRequestData), aLocation, std::move(aFlags), std::move(aCanGoBack), std::move(aCanGoForward), std::move(aLocationChangeData));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_OnProgressChange__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_OnProgressChange", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aCurTotalProgress = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aCurTotalProgress) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aCurTotalProgress = *maybe__aCurTotalProgress;
// Sentinel = 'aCurTotalProgress'
if ((!(((&(reader__)))->ReadSentinel(1012795109)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto maybe__aMaxTotalProgress = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aMaxTotalProgress) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aMaxTotalProgress = *maybe__aMaxTotalProgress;
// Sentinel = 'aMaxTotalProgress'
if ((!(((&(reader__)))->ReadSentinel(1009125089)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvOnProgressChange(std::move(aCurTotalProgress), std::move(aMaxTotalProgress));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_OnStatusChange__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_OnStatusChange", 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;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvOnStatusChange(std::move(aMessage));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NotifyContentBlockingEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyContentBlockingEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEvent = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aEvent) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aEvent = *maybe__aEvent;
// Sentinel = 'aEvent'
if ((!(((&(reader__)))->ReadSentinel(133956196)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aRequestData = IPC::ReadParam<RequestData>((&(reader__)));
if (!maybe__aRequestData) {
FatalError("Error deserializing 'RequestData'");
return MsgValueError;
}
auto& aRequestData = *maybe__aRequestData;
// Sentinel = 'aRequestData'
if ((!(((&(reader__)))->ReadSentinel(518390981)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'RequestData'");
return MsgValueError;
}
auto maybe__aBlocked = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aBlocked) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aBlocked = *maybe__aBlocked;
// Sentinel = 'aBlocked'
if ((!(((&(reader__)))->ReadSentinel(227279638)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aTrackingOrigin = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aTrackingOrigin) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aTrackingOrigin = *maybe__aTrackingOrigin;
// Sentinel = 'aTrackingOrigin'
if ((!(((&(reader__)))->ReadSentinel(792331773)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aTrackingFullHashes = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
if (!maybe__aTrackingFullHashes) {
FatalError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto& aTrackingFullHashes = *maybe__aTrackingFullHashes;
// Sentinel = 'aTrackingFullHashes'
if ((!(((&(reader__)))->ReadSentinel(1248069508)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto maybe__aReason = IPC::ReadParam<mozilla::Maybe<StorageAccessPermissionGrantedReason>>((&(reader__)));
if (!maybe__aReason) {
FatalError("Error deserializing 'StorageAccessPermissionGrantedReason?'");
return MsgValueError;
}
auto& aReason = *maybe__aReason;
// Sentinel = 'aReason'
if ((!(((&(reader__)))->ReadSentinel(180093642)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'StorageAccessPermissionGrantedReason?'");
return MsgValueError;
}
auto maybe__aCanvasFingerprinter = IPC::ReadParam<mozilla::Maybe<CanvasFingerprinter>>((&(reader__)));
if (!maybe__aCanvasFingerprinter) {
FatalError("Error deserializing 'CanvasFingerprinter?'");
return MsgValueError;
}
auto& aCanvasFingerprinter = *maybe__aCanvasFingerprinter;
// Sentinel = 'aCanvasFingerprinter'
if ((!(((&(reader__)))->ReadSentinel(1384777757)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CanvasFingerprinter?'");
return MsgValueError;
}
auto maybe__aCanvasFingerprinterKnownText = IPC::ReadParam<mozilla::Maybe<bool>>((&(reader__)));
if (!maybe__aCanvasFingerprinterKnownText) {
FatalError("Error deserializing 'bool?'");
return MsgValueError;
}
auto& aCanvasFingerprinterKnownText = *maybe__aCanvasFingerprinterKnownText;
// Sentinel = 'aCanvasFingerprinterKnownText'
if ((!(((&(reader__)))->ReadSentinel(2910718927)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNotifyContentBlockingEvent(std::move(aEvent), std::move(aRequestData), std::move(aBlocked), std::move(aTrackingOrigin), std::move(aTrackingFullHashes), std::move(aReason), std::move(aCanvasFingerprinter), std::move(aCanvasFingerprinterKnownText));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NavigationFinished__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NavigationFinished", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNavigationFinished();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_IntrinsicSizeOrRatioChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_IntrinsicSizeOrRatioChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aIntrinsicSize = IPC::ReadParam<mozilla::Maybe<IntrinsicSize>>((&(reader__)));
if (!maybe__aIntrinsicSize) {
FatalError("Error deserializing 'IntrinsicSize?'");
return MsgValueError;
}
auto& aIntrinsicSize = *maybe__aIntrinsicSize;
// Sentinel = 'aIntrinsicSize'
if ((!(((&(reader__)))->ReadSentinel(708052400)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IntrinsicSize?'");
return MsgValueError;
}
auto maybe__aIntrinsicRatio = IPC::ReadParam<mozilla::Maybe<AspectRatio>>((&(reader__)));
if (!maybe__aIntrinsicRatio) {
FatalError("Error deserializing 'AspectRatio?'");
return MsgValueError;
}
auto& aIntrinsicRatio = *maybe__aIntrinsicRatio;
// Sentinel = 'aIntrinsicRatio'
if ((!(((&(reader__)))->ReadSentinel(807667220)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'AspectRatio?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvIntrinsicSizeOrRatioChanged(std::move(aIntrinsicSize), std::move(aIntrinsicRatio));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_ImageLoadComplete__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ImageLoadComplete", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aResult = IPC::ReadParam<nsresult>((&(reader__)));
if (!maybe__aResult) {
FatalError("Error deserializing 'nsresult'");
return MsgValueError;
}
auto& aResult = *maybe__aResult;
// Sentinel = 'aResult'
if ((!(((&(reader__)))->ReadSentinel(185205473)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvImageLoadComplete(std::move(aResult));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_RequestPointerLock__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RequestPointerLock", OTHER);
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PBrowser::Reply_RequestPointerLock(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestPointerLockResolver resolver = [resolver__ = std::move(resolver__)](const nsACString& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'error'
((&(writer__)))->WriteSentinel(107741739);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvRequestPointerLock(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_ReleasePointerLock__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ReleasePointerLock", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvReleasePointerLock();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_RequestPointerCapture__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RequestPointerCapture", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPointerId = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aPointerId) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aPointerId = *maybe__aPointerId;
// Sentinel = 'aPointerId'
if ((!(((&(reader__)))->ReadSentinel(364053488)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PBrowser::Reply_RequestPointerCapture(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestPointerCaptureResolver 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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvRequestPointerCapture(std::move(aPointerId), 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_ReleasePointerCapture__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ReleasePointerCapture", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPointerId = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aPointerId) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aPointerId = *maybe__aPointerId;
// Sentinel = 'aPointerId'
if ((!(((&(reader__)))->ReadSentinel(364053488)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvReleasePointerCapture(std::move(aPointerId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Reply_CloneDocumentTreeIntoSelf__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_CloneDocumentTreeIntoSelf", 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_RemoteIsReadyToHandleInputEvents__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RemoteIsReadyToHandleInputEvents", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvRemoteIsReadyToHandleInputEvents();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_SetDimensions__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SetDimensions", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aRequest = IPC::ReadParam<DimensionRequest>((&(reader__)));
if (!maybe__aRequest) {
FatalError("Error deserializing 'DimensionRequest'");
return MsgValueError;
}
auto& aRequest = *maybe__aRequest;
// Sentinel = 'aRequest'
if ((!(((&(reader__)))->ReadSentinel(238945099)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'DimensionRequest'");
return MsgValueError;
}
auto maybe__aScale = IPC::ReadParam<double>((&(reader__)));
if (!maybe__aScale) {
FatalError("Error deserializing 'double'");
return MsgValueError;
}
auto& aScale = *maybe__aScale;
// Sentinel = 'aScale'
if ((!(((&(reader__)))->ReadSentinel(131531338)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'double'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSetDimensions(std::move(aRequest), std::move(aScale));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_InvokeDragSession__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_InvokeDragSession", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__transfers = IPC::ReadParam<nsTArray<IPCTransferableData>>((&(reader__)));
if (!maybe__transfers) {
FatalError("Error deserializing 'IPCTransferableData[]'");
return MsgValueError;
}
auto& transfers = *maybe__transfers;
// Sentinel = 'transfers'
if ((!(((&(reader__)))->ReadSentinel(323290073)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCTransferableData[]'");
return MsgValueError;
}
auto maybe__action = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__action) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& action = *maybe__action;
// Sentinel = 'action'
if ((!(((&(reader__)))->ReadSentinel(143786623)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__visualData = IPC::ReadParam<mozilla::Maybe<BigBuffer>>((&(reader__)));
if (!maybe__visualData) {
FatalError("Error deserializing 'BigBuffer?'");
return MsgValueError;
}
auto& visualData = *maybe__visualData;
// Sentinel = 'visualData'
if ((!(((&(reader__)))->ReadSentinel(385877007)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'BigBuffer?'");
return MsgValueError;
}
auto maybe__stride = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__stride) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& stride = *maybe__stride;
// Sentinel = 'stride'
if ((!(((&(reader__)))->ReadSentinel(153879180)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__format = IPC::ReadParam<SurfaceFormat>((&(reader__)));
if (!maybe__format) {
FatalError("Error deserializing 'SurfaceFormat'");
return MsgValueError;
}
auto& format = *maybe__format;
// Sentinel = 'format'
if ((!(((&(reader__)))->ReadSentinel(148505226)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SurfaceFormat'");
return MsgValueError;
}
auto maybe__dragRect = IPC::ReadParam<LayoutDeviceIntRect>((&(reader__)));
if (!maybe__dragRect) {
FatalError("Error deserializing 'LayoutDeviceIntRect'");
return MsgValueError;
}
auto& dragRect = *maybe__dragRect;
// Sentinel = 'dragRect'
if ((!(((&(reader__)))->ReadSentinel(239076141)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntRect'");
return MsgValueError;
}
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__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;
}
auto maybe__cookieJarSettings = IPC::ReadParam<CookieJarSettingsArgs>((&(reader__)));
if (!maybe__cookieJarSettings) {
FatalError("Error deserializing 'CookieJarSettingsArgs'");
return MsgValueError;
}
auto& cookieJarSettings = *maybe__cookieJarSettings;
// Sentinel = 'cookieJarSettings'
if ((!(((&(reader__)))->ReadSentinel(1031800553)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CookieJarSettingsArgs'");
return MsgValueError;
}
auto maybe__sourceWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
if (!maybe__sourceWindowContext) {
FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto& sourceWindowContext = *maybe__sourceWindowContext;
// Sentinel = 'sourceWindowContext'
if ((!(((&(reader__)))->ReadSentinel(1328678895)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto maybe__sourceTopWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
if (!maybe__sourceTopWindowContext) {
FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto& sourceTopWindowContext = *maybe__sourceTopWindowContext;
// Sentinel = 'sourceTopWindowContext'
if ((!(((&(reader__)))->ReadSentinel(1758005538)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvInvokeDragSession(std::move(transfers), std::move(action), std::move(visualData), std::move(stride), std::move(format), std::move(dragRect), principal, csp, std::move(cookieJarSettings), std::move(sourceWindowContext), std::move(sourceTopWindowContext));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_ShowCanvasPermissionPrompt__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ShowCanvasPermissionPrompt", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aOrigin = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aOrigin) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aOrigin = *maybe__aOrigin;
// Sentinel = 'aOrigin'
if ((!(((&(reader__)))->ReadSentinel(182125258)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aHideDoorHanger = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aHideDoorHanger) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aHideDoorHanger = *maybe__aHideDoorHanger;
// Sentinel = 'aHideDoorHanger'
if ((!(((&(reader__)))->ReadSentinel(753731013)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvShowCanvasPermissionPrompt(std::move(aOrigin), std::move(aHideDoorHanger));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_MaybeFireEmbedderLoadEvents__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_MaybeFireEmbedderLoadEvents", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aFireEventAtEmbeddingElement = IPC::ReadParam<EmbedderElementEventType>((&(reader__)));
if (!maybe__aFireEventAtEmbeddingElement) {
FatalError("Error deserializing 'EmbedderElementEventType'");
return MsgValueError;
}
auto& aFireEventAtEmbeddingElement = *maybe__aFireEventAtEmbeddingElement;
// Sentinel = 'aFireEventAtEmbeddingElement'
if ((!(((&(reader__)))->ReadSentinel(2607483624)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'EmbedderElementEventType'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvMaybeFireEmbedderLoadEvents(std::move(aFireEventAtEmbeddingElement));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_ScrollRectIntoView__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ScrollRectIntoView", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aRect = IPC::ReadParam<nsRect>((&(reader__)));
if (!maybe__aRect) {
FatalError("Error deserializing 'nsRect'");
return MsgValueError;
}
auto& aRect = *maybe__aRect;
// Sentinel = 'aRect'
if ((!(((&(reader__)))->ReadSentinel(94044656)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsRect'");
return MsgValueError;
}
auto maybe__aVertical = IPC::ReadParam<ScrollAxis>((&(reader__)));
if (!maybe__aVertical) {
FatalError("Error deserializing 'ScrollAxis'");
return MsgValueError;
}
auto& aVertical = *maybe__aVertical;
// Sentinel = 'aVertical'
if ((!(((&(reader__)))->ReadSentinel(298845084)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollAxis'");
return MsgValueError;
}
auto maybe__aHorizontal = IPC::ReadParam<ScrollAxis>((&(reader__)));
if (!maybe__aHorizontal) {
FatalError("Error deserializing 'ScrollAxis'");
return MsgValueError;
}
auto& aHorizontal = *maybe__aHorizontal;
// Sentinel = 'aHorizontal'
if ((!(((&(reader__)))->ReadSentinel(447022220)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollAxis'");
return MsgValueError;
}
auto maybe__aScrollFlags = IPC::ReadParam<ScrollFlags>((&(reader__)));
if (!maybe__aScrollFlags) {
FatalError("Error deserializing 'ScrollFlags'");
return MsgValueError;
}
auto& aScrollFlags = *maybe__aScrollFlags;
// Sentinel = 'aScrollFlags'
if ((!(((&(reader__)))->ReadSentinel(510592190)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScrollFlags'");
return MsgValueError;
}
auto maybe__aAppUnitsPerDevPixel = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aAppUnitsPerDevPixel) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aAppUnitsPerDevPixel = *maybe__aAppUnitsPerDevPixel;
// Sentinel = 'aAppUnitsPerDevPixel'
if ((!(((&(reader__)))->ReadSentinel(1366296542)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvScrollRectIntoView(std::move(aRect), std::move(aVertical), std::move(aHorizontal), std::move(aScrollFlags), std::move(aAppUnitsPerDevPixel));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_ShowDynamicToolbar__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_ShowDynamicToolbar", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvShowDynamicToolbar();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Reply_PrintPreview__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PrintPreview", 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<PrintPreviewResultInfo> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__aInfo = IPC::ReadParam<PrintPreviewResultInfo>((&(reader__)));
if (!maybe__aInfo) {
FatalError("Error deserializing 'PrintPreviewResultInfo'");
return MsgValueError;
}
auto& aInfo = *maybe__aInfo;
// Sentinel = 'aInfo'
if ((!(((&(reader__)))->ReadSentinel(93520366)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PrintPreviewResultInfo'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(aInfo));
} 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_Print__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_Print", 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<MaybeDiscardedBrowsingContext> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__staticCloneBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__staticCloneBrowsingContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& staticCloneBrowsingContext = *maybe__staticCloneBrowsingContext;
// Sentinel = 'staticCloneBrowsingContext'
if ((!(((&(reader__)))->ReadSentinel(2396719786)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(staticCloneBrowsingContext));
} 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_IsWindowSupportingProtectedMedia__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_IsWindowSupportingProtectedMedia", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aOuterWindowID = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aOuterWindowID) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aOuterWindowID = *maybe__aOuterWindowID;
// Sentinel = 'aOuterWindowID'
if ((!(((&(reader__)))->ReadSentinel(702612854)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PBrowser::Reply_IsWindowSupportingProtectedMedia(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
IsWindowSupportingProtectedMediaResolver 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 = 'isSupported'
((&(writer__)))->WriteSentinel(466355363);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvIsWindowSupportingProtectedMedia(std::move(aOuterWindowID), 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_IsWindowSupportingWebVR__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_IsWindowSupportingWebVR", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aOuterWindowID = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aOuterWindowID) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aOuterWindowID = *maybe__aOuterWindowID;
// Sentinel = 'aOuterWindowID'
if ((!(((&(reader__)))->ReadSentinel(702612854)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PBrowser::Reply_IsWindowSupportingWebVR(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
IsWindowSupportingWebVRResolver 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 = 'isSupported'
((&(writer__)))->WriteSentinel(466355363);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvIsWindowSupportingWebVR(std::move(aOuterWindowID), 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_VisitURI__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_VisitURI", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aURI = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__aURI) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& aURI = *maybe__aURI;
// Sentinel = 'aURI'
if ((!(((&(reader__)))->ReadSentinel(57934162)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__aLastVisitedURI = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__aLastVisitedURI) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& aLastVisitedURI = *maybe__aLastVisitedURI;
// Sentinel = 'aLastVisitedURI'
if ((!(((&(reader__)))->ReadSentinel(786695614)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__aFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aFlags = *maybe__aFlags;
// Sentinel = 'aFlags'
if ((!(((&(reader__)))->ReadSentinel(129892943)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aBrowserId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aBrowserId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aBrowserId = *maybe__aBrowserId;
// Sentinel = 'aBrowserId'
if ((!(((&(reader__)))->ReadSentinel(363332595)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvVisitURI(aURI, aLastVisitedURI, std::move(aFlags), std::move(aBrowserId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_QueryVisitedState__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_QueryVisitedState", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aURIs = IPC::ReadParam<nsTArray<RefPtr<nsIURI>>>((&(reader__)));
if (!maybe__aURIs) {
FatalError("Error deserializing 'nsIURI[]'");
return MsgValueError;
}
auto& aURIs = *maybe__aURIs;
// Sentinel = 'aURIs'
if ((!(((&(reader__)))->ReadSentinel(87622085)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvQueryVisitedState(std::move(aURIs));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_PSessionStoreConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_PSessionStoreConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PSessionStoreParent> actor = (static_cast<BrowserParent*>(this))->AllocPSessionStoreParent();
if (!actor) {
NS_WARNING("Cannot bind null PSessionStoreParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPSessionStoreParent.Insert(actor);
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvPSessionStoreConstructor(actor);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PBrowser::Msg_NewWindowGlobal__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NewWindowGlobal", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEndpoint = IPC::ReadParam<ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>>((&(reader__)));
if (!maybe__aEndpoint) {
FatalError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>'");
return MsgValueError;
}
auto& aEndpoint = *maybe__aEndpoint;
// Sentinel = 'aEndpoint'
if ((!(((&(reader__)))->ReadSentinel(292225955)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>'");
return MsgValueError;
}
auto maybe__aInit = IPC::ReadParam<WindowGlobalInit>((&(reader__)));
if (!maybe__aInit) {
FatalError("Error deserializing 'WindowGlobalInit'");
return MsgValueError;
}
auto& aInit = *maybe__aInit;
// Sentinel = 'aInit'
if ((!(((&(reader__)))->ReadSentinel(94241270)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WindowGlobalInit'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNewWindowGlobal(std::move(aEndpoint), std::move(aInit));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
default:
return MsgNotKnown;
}
}
auto PBrowserParent::OnMessageReceived(
const Message& msg__,
UniquePtr<Message>& reply__) -> PBrowserParent::Result
{
switch (msg__.type()) {
case PBrowser::Msg_SyncMessage__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SyncMessage", 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();
int32_t id__ = Id();
nsTArray<StructuredCloneData> retval{};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSyncMessage(std::move(aMessage), std::move(aData), (&(retval)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PBrowser::Reply_SyncMessage(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), retval);
// Sentinel = 'retval'
((&(writer__)))->WriteSentinel(151716495);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PBrowser::Msg_NotifyIMEMouseButtonEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMEMouseButtonEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__notification = IPC::ReadParam<IMENotification>((&(reader__)));
if (!maybe__notification) {
FatalError("Error deserializing 'IMENotification'");
return MsgValueError;
}
auto& notification = *maybe__notification;
// Sentinel = 'notification'
if ((!(((&(reader__)))->ReadSentinel(550438152)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IMENotification'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = Id();
bool consumedByIME{};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNotifyIMEMouseButtonEvent(std::move(notification), (&(consumedByIME)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PBrowser::Reply_NotifyIMEMouseButtonEvent(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), consumedByIME);
// Sentinel = 'consumedByIME'
((&(writer__)))->WriteSentinel(621282549);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PBrowser::Msg_RequestIMEToCommitComposition__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RequestIMEToCommitComposition", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__cancel = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__cancel) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& cancel = *maybe__cancel;
// Sentinel = 'cancel'
if ((!(((&(reader__)))->ReadSentinel(139723367)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aCompositionId = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aCompositionId) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aCompositionId = *maybe__aCompositionId;
// Sentinel = 'aCompositionId'
if ((!(((&(reader__)))->ReadSentinel(707069347)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = Id();
bool isCommitted{};
nsString committedString{};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvRequestIMEToCommitComposition(std::move(cancel), std::move(aCompositionId), (&(isCommitted)), (&(committedString)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PBrowser::Reply_RequestIMEToCommitComposition(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), isCommitted);
// Sentinel = 'isCommitted'
((&(writer__)))->WriteSentinel(449774723);
IPC::WriteParam((&(writer__)), committedString);
// Sentinel = 'committedString'
((&(writer__)))->WriteSentinel(840042046);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PBrowser::Msg_GetInputContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_GetInputContext", OTHER);
int32_t id__ = Id();
IMEState state{};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvGetInputContext((&(state)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PBrowser::Reply_GetInputContext(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), state);
// Sentinel = 'state'
((&(writer__)))->WriteSentinel(109314594);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PBrowser::Msg_RequestNativeKeyBindings__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_RequestNativeKeyBindings", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aType = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aType) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aType = *maybe__aType;
// Sentinel = 'aType'
if ((!(((&(reader__)))->ReadSentinel(99222020)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
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;
}
reader__.EndRead();
int32_t id__ = Id();
nsTArray<CommandInt> commands{};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvRequestNativeKeyBindings(std::move(aType), std::move(aEvent), (&(commands)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PBrowser::Reply_RequestNativeKeyBindings(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), commands);
// Sentinel = 'commands'
((&(writer__)))->WriteSentinel(249627475);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PBrowser::Msg_DispatchWheelEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DispatchWheelEvent", 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;
}
reader__.EndRead();
int32_t id__ = Id();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvDispatchWheelEvent(std::move(event));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PBrowser::Reply_DispatchWheelEvent(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PBrowser::Msg_DispatchMouseEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DispatchMouseEvent", 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;
}
reader__.EndRead();
int32_t id__ = Id();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvDispatchMouseEvent(std::move(event));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PBrowser::Reply_DispatchMouseEvent(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PBrowser::Msg_DispatchKeyboardEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DispatchKeyboardEvent", 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;
}
reader__.EndRead();
int32_t id__ = Id();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvDispatchKeyboardEvent(std::move(event));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PBrowser::Reply_DispatchKeyboardEvent(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PBrowser::Msg_DispatchTouchEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_DispatchTouchEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<WidgetTouchEvent>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'WidgetTouchEvent'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WidgetTouchEvent'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = Id();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvDispatchTouchEvent(std::move(event));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PBrowser::Reply_DispatchTouchEvent(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PBrowser::Msg_EnsureLayersConnected__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_EnsureLayersConnected", OTHER);
int32_t id__ = Id();
CompositorOptions compositorOptions{};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvEnsureLayersConnected((&(compositorOptions)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PBrowser::Reply_EnsureLayersConnected(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), compositorOptions);
// Sentinel = 'compositorOptions'
((&(writer__)))->WriteSentinel(1089275708);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PBrowser::Msg_SetSystemFont__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_SetSystemFont", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aFontName = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aFontName) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aFontName = *maybe__aFontName;
// Sentinel = 'aFontName'
if ((!(((&(reader__)))->ReadSentinel(287114106)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = Id();
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSetSystemFont(std::move(aFontName));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PBrowser::Reply_SetSystemFont(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PBrowser::Msg_GetSystemFont__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PBrowser::Msg_GetSystemFont", OTHER);
int32_t id__ = Id();
nsCString retval{};
mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvGetSystemFont((&(retval)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PBrowser::Reply_GetSystemFont(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), retval);
// Sentinel = 'retval'
((&(writer__)))->WriteSentinel(151716495);
if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PBrowserParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
default:
return MsgNotKnown;
}
}
auto PBrowserParent::ClearSubtree() -> void
{
for (auto* key : mManagedPColorPickerParent) {
key->ClearSubtree();
}
for (auto* key : mManagedPColorPickerParent) {
// Recursively releasing mManagedPColorPickerParent kids.
auto* proxy = key->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
}
mManagedPColorPickerParent.Clear();
for (auto* key : mManagedPDocAccessibleParent) {
key->ClearSubtree();
}
for (auto* key : mManagedPDocAccessibleParent) {
// Recursively releasing mManagedPDocAccessibleParent kids.
auto* proxy = key->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
}
mManagedPDocAccessibleParent.Clear();
for (auto* key : mManagedPFilePickerParent) {
key->ClearSubtree();
}
for (auto* key : mManagedPFilePickerParent) {
// Recursively releasing mManagedPFilePickerParent kids.
auto* proxy = key->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
}
mManagedPFilePickerParent.Clear();
for (auto* key : mManagedPPaymentRequestParent) {
key->ClearSubtree();
}
for (auto* key : mManagedPPaymentRequestParent) {
// Recursively releasing mManagedPPaymentRequestParent kids.
auto* proxy = key->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
}
mManagedPPaymentRequestParent.Clear();
for (auto* key : mManagedPSessionStoreParent) {
key->ClearSubtree();
}
for (auto* key : mManagedPSessionStoreParent) {
// Recursively releasing mManagedPSessionStoreParent kids.
auto* proxy = key->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
}
mManagedPSessionStoreParent.Clear();
for (auto* key : mManagedPWindowGlobalParent) {
key->ClearSubtree();
}
for (auto* key : mManagedPWindowGlobalParent) {
// Recursively releasing mManagedPWindowGlobalParent kids.
auto* proxy = key->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
}
mManagedPWindowGlobalParent.Clear();
for (auto* key : mManagedPBrowserBridgeParent) {
key->ClearSubtree();
}
for (auto* key : mManagedPBrowserBridgeParent) {
// Recursively releasing mManagedPBrowserBridgeParent kids.
auto* proxy = key->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
}
mManagedPBrowserBridgeParent.Clear();
for (auto* key : mManagedPVsyncParent) {
key->ClearSubtree();
}
for (auto* key : mManagedPVsyncParent) {
// Recursively releasing mManagedPVsyncParent kids.
auto* proxy = key->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
}
mManagedPVsyncParent.Clear();
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::PBrowserParent*>::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::PBrowserParent*>::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::PBrowserParent*>(actor.ref());
}
return {};
}
} // namespace IPC