Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/PContentChild.h"
#include "ipc/ErrorIPCUtils.h"
#include "ipc/MediaControlIPC.h"
#include "mozilla/AlertNotificationIPCSerializer.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/D3DMessageUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/PermissionDelegateIPCUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/ProfilerMarkers.h"
#include "mozilla/RemoteLazyInputStream.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/chrome/RegistryMessageUtils.h"
#include "mozilla/dom/BindingIPCUtils.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/ClientIPCUtils.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/dom/FeaturePolicyUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/GeolocationIPCUtils.h"
#include "mozilla/dom/MediaSessionIPCUtils.h"
#include "mozilla/dom/MessagePort.h"
#include "mozilla/dom/PageLoadEventUtils.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/SessionHistoryEntry.h"
#include "mozilla/dom/TabMessageUtils.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"
#include "mozilla/glean/GleanMetrics.h"
#include "mozilla/ipc/BigBuffer.h"
#include "mozilla/ipc/ByteBufUtils.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/LayersMessageUtils.h"
#include "mozilla/net/CacheInfoIPCTypes.h"
#include "mozilla/net/ClassOfService.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "mozilla/widget/WidgetMessageUtils.h"
#include "nsDOMNavigationTiming.h"
#include "nsDocShellLoadState.h"
#include "nsGeoPositionIPCSerialiser.h"
#include "nsHttp.h"
#include "nsHttpResponseHead.h"
#include "nsIContentSecurityPolicy.h"
#include "nsID.h"
#include "nsILayoutHistoryState.h"
#include "nsIPrincipal.h"
#include "nsIPropertyBag2.h"
#include "nsIReferrerInfo.h"
#include "nsITransportSecurityInfo.h"
#include "nsIURI.h"
#include "nsIVariant.h"
#include "nsIX509Cert.h"
#include "nsPoint.h"
#include "mozilla/ipc/PBackgroundStarterChild.h"
#include "mozilla/dom/PBrowserChild.h"
#include "mozilla/PClipboardContentAnalysisChild.h"
#include "mozilla/PClipboardReadRequestChild.h"
#include "mozilla/PClipboardWriteRequestChild.h"
#include "mozilla/layers/PCompositorManagerChild.h"
#include "mozilla/dom/PContentPermissionRequestChild.h"
#include "mozilla/dom/PCycleCollectWithLogsChild.h"
#include "mozilla/net/PDocumentChannelChild.h"
#include "mozilla/extensions/PExtensionsChild.h"
#include "mozilla/dom/PExternalHelperAppChild.h"
#include "mozilla/dom/PHandlerServiceChild.h"
#include "mozilla/hal_sandbox/PHalChild.h"
#include "mozilla/devtools/PHeapSnapshotTempFileHelperChild.h"
#include "mozilla/PProcessHangMonitorChild.h"
#include "mozilla/layers/PImageBridgeChild.h"
#include "mozilla/layout/PRemotePrintJobChild.h"
#include "mozilla/media/PMediaChild.h"
#include "mozilla/net/PNeckoChild.h"
#include "mozilla/extensions/PStreamFilterChild.h"
#include "mozilla/gmp/PGMPContentChild.h"
#include "mozilla/gmp/PGMPServiceChild.h"
#include "mozilla/gmp/PGMPChild.h"
#include "mozilla/dom/PSpeechSynthesisChild.h"
#include "mozilla/ipc/PTestShellChild.h"
#include "mozilla/PRemoteSpellcheckEngineChild.h"
#include "mozilla/PWebBrowserPersistDocumentChild.h"
#include "mozilla/dom/PWebrtcGlobalChild.h"
#include "mozilla/dom/PWindowGlobalChild.h"
#include "mozilla/dom/PURLClassifierChild.h"
#include "mozilla/dom/PURLClassifierLocalChild.h"
#include "mozilla/gfx/PVRManagerChild.h"
#include "mozilla/PRemoteDecoderManagerChild.h"
#include "mozilla/dom/PRemoteWorkerServiceChild.h"
#include "mozilla/PProfilerChild.h"
#include "mozilla/loader/PScriptCacheChild.h"
#include "mozilla/dom/PSessionStorageObserverChild.h"
#include "mozilla/PBenchmarkStorageChild.h"
#include "mozilla/PSandboxTestingChild.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 PContentChild::RecvPWebBrowserPersistDocumentConstructor(
PWebBrowserPersistDocumentChild* actor,
PBrowserChild* aBrowser,
const MaybeDiscardedBrowsingContext& aContext) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentChild::RecvPCycleCollectWithLogsConstructor(
PCycleCollectWithLogsChild* actor,
const bool& dumpAllTraces,
const FileDescriptor& gcLog,
const FileDescriptor& ccLog) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentChild::RecvPTestShellConstructor(PTestShellChild* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentChild::RecvPScriptCacheConstructor(
PScriptCacheChild* actor,
const FileDescOrError& cacheFile,
const bool& wantCacheData) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentChild::RecvPRemotePrintJobConstructor(PRemotePrintJobChild* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentChild::ProcessingError(
Result aCode,
const char* aReason) -> void
{
}
auto PContentChild::ShouldContinueFromReplyTimeout() -> bool
{
return true;
}
MOZ_IMPLICIT PContentChild::PContentChild() :
mozilla::ipc::IToplevelProtocol("PContentChild", kProtocolId, mozilla::ipc::ChildSide)
{
MOZ_COUNT_CTOR(PContentChild);
}
PContentChild::~PContentChild()
{
MOZ_COUNT_DTOR(PContentChild);
}
auto PContentChild::ActorAlloc() -> void
{
MOZ_RELEASE_ASSERT(XRE_IsContentProcess(), "Invalid process for `PContentChild'");
AddRef();
}
auto PContentChild::ActorDealloc() -> void
{
Release();
}
auto PContentChild::OtherPid() const -> ::base::ProcessId
{
::base::ProcessId pid =
::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherPidMaybeInvalid();
MOZ_RELEASE_ASSERT(pid != ::base::kInvalidProcessId);
return pid;
}
auto PContentChild::OtherChildID() const -> ::GeckoChildID
{
::GeckoChildID childID =
::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherChildIDMaybeInvalid();
MOZ_RELEASE_ASSERT(childID != -1);
return childID;
}
auto PContentChild::OtherEndpointProcInfo() const -> ::mozilla::ipc::EndpointProcInfo
{
return ::mozilla::ipc::EndpointProcInfo{OtherPid(), OtherChildID()};
}
auto PContentChild::ManagedPBrowserChild(nsTArray<PBrowserChild*>& aArr) const -> void
{
mManagedPBrowserChild.ToArray(aArr);
}
auto PContentChild::ManagedPBrowserChild() const -> const ManagedContainer<PBrowserChild>&
{
return mManagedPBrowserChild;
}
auto PContentChild::ManagedPClipboardReadRequestChild(nsTArray<PClipboardReadRequestChild*>& aArr) const -> void
{
mManagedPClipboardReadRequestChild.ToArray(aArr);
}
auto PContentChild::ManagedPClipboardReadRequestChild() const -> const ManagedContainer<PClipboardReadRequestChild>&
{
return mManagedPClipboardReadRequestChild;
}
auto PContentChild::ManagedPClipboardWriteRequestChild(nsTArray<PClipboardWriteRequestChild*>& aArr) const -> void
{
mManagedPClipboardWriteRequestChild.ToArray(aArr);
}
auto PContentChild::ManagedPClipboardWriteRequestChild() const -> const ManagedContainer<PClipboardWriteRequestChild>&
{
return mManagedPClipboardWriteRequestChild;
}
auto PContentChild::ManagedPContentPermissionRequestChild(nsTArray<PContentPermissionRequestChild*>& aArr) const -> void
{
mManagedPContentPermissionRequestChild.ToArray(aArr);
}
auto PContentChild::ManagedPContentPermissionRequestChild() const -> const ManagedContainer<PContentPermissionRequestChild>&
{
return mManagedPContentPermissionRequestChild;
}
auto PContentChild::ManagedPCycleCollectWithLogsChild(nsTArray<PCycleCollectWithLogsChild*>& aArr) const -> void
{
mManagedPCycleCollectWithLogsChild.ToArray(aArr);
}
auto PContentChild::ManagedPCycleCollectWithLogsChild() const -> const ManagedContainer<PCycleCollectWithLogsChild>&
{
return mManagedPCycleCollectWithLogsChild;
}
auto PContentChild::ManagedPExtensionsChild(nsTArray<PExtensionsChild*>& aArr) const -> void
{
mManagedPExtensionsChild.ToArray(aArr);
}
auto PContentChild::ManagedPExtensionsChild() const -> const ManagedContainer<PExtensionsChild>&
{
return mManagedPExtensionsChild;
}
auto PContentChild::ManagedPExternalHelperAppChild(nsTArray<PExternalHelperAppChild*>& aArr) const -> void
{
mManagedPExternalHelperAppChild.ToArray(aArr);
}
auto PContentChild::ManagedPExternalHelperAppChild() const -> const ManagedContainer<PExternalHelperAppChild>&
{
return mManagedPExternalHelperAppChild;
}
auto PContentChild::ManagedPHalChild(nsTArray<PHalChild*>& aArr) const -> void
{
mManagedPHalChild.ToArray(aArr);
}
auto PContentChild::ManagedPHalChild() const -> const ManagedContainer<PHalChild>&
{
return mManagedPHalChild;
}
auto PContentChild::ManagedPHandlerServiceChild(nsTArray<PHandlerServiceChild*>& aArr) const -> void
{
mManagedPHandlerServiceChild.ToArray(aArr);
}
auto PContentChild::ManagedPHandlerServiceChild() const -> const ManagedContainer<PHandlerServiceChild>&
{
return mManagedPHandlerServiceChild;
}
auto PContentChild::ManagedPHeapSnapshotTempFileHelperChild(nsTArray<PHeapSnapshotTempFileHelperChild*>& aArr) const -> void
{
mManagedPHeapSnapshotTempFileHelperChild.ToArray(aArr);
}
auto PContentChild::ManagedPHeapSnapshotTempFileHelperChild() const -> const ManagedContainer<PHeapSnapshotTempFileHelperChild>&
{
return mManagedPHeapSnapshotTempFileHelperChild;
}
auto PContentChild::ManagedPRemotePrintJobChild(nsTArray<PRemotePrintJobChild*>& aArr) const -> void
{
mManagedPRemotePrintJobChild.ToArray(aArr);
}
auto PContentChild::ManagedPRemotePrintJobChild() const -> const ManagedContainer<PRemotePrintJobChild>&
{
return mManagedPRemotePrintJobChild;
}
auto PContentChild::ManagedPMediaChild(nsTArray<PMediaChild*>& aArr) const -> void
{
mManagedPMediaChild.ToArray(aArr);
}
auto PContentChild::ManagedPMediaChild() const -> const ManagedContainer<PMediaChild>&
{
return mManagedPMediaChild;
}
auto PContentChild::ManagedPNeckoChild(nsTArray<PNeckoChild*>& aArr) const -> void
{
mManagedPNeckoChild.ToArray(aArr);
}
auto PContentChild::ManagedPNeckoChild() const -> const ManagedContainer<PNeckoChild>&
{
return mManagedPNeckoChild;
}
auto PContentChild::ManagedPSpeechSynthesisChild(nsTArray<PSpeechSynthesisChild*>& aArr) const -> void
{
mManagedPSpeechSynthesisChild.ToArray(aArr);
}
auto PContentChild::ManagedPSpeechSynthesisChild() const -> const ManagedContainer<PSpeechSynthesisChild>&
{
return mManagedPSpeechSynthesisChild;
}
auto PContentChild::ManagedPTestShellChild(nsTArray<PTestShellChild*>& aArr) const -> void
{
mManagedPTestShellChild.ToArray(aArr);
}
auto PContentChild::ManagedPTestShellChild() const -> const ManagedContainer<PTestShellChild>&
{
return mManagedPTestShellChild;
}
auto PContentChild::ManagedPRemoteSpellcheckEngineChild(nsTArray<PRemoteSpellcheckEngineChild*>& aArr) const -> void
{
mManagedPRemoteSpellcheckEngineChild.ToArray(aArr);
}
auto PContentChild::ManagedPRemoteSpellcheckEngineChild() const -> const ManagedContainer<PRemoteSpellcheckEngineChild>&
{
return mManagedPRemoteSpellcheckEngineChild;
}
auto PContentChild::ManagedPWebBrowserPersistDocumentChild(nsTArray<PWebBrowserPersistDocumentChild*>& aArr) const -> void
{
mManagedPWebBrowserPersistDocumentChild.ToArray(aArr);
}
auto PContentChild::ManagedPWebBrowserPersistDocumentChild() const -> const ManagedContainer<PWebBrowserPersistDocumentChild>&
{
return mManagedPWebBrowserPersistDocumentChild;
}
auto PContentChild::ManagedPWebrtcGlobalChild(nsTArray<PWebrtcGlobalChild*>& aArr) const -> void
{
mManagedPWebrtcGlobalChild.ToArray(aArr);
}
auto PContentChild::ManagedPWebrtcGlobalChild() const -> const ManagedContainer<PWebrtcGlobalChild>&
{
return mManagedPWebrtcGlobalChild;
}
auto PContentChild::ManagedPURLClassifierChild(nsTArray<PURLClassifierChild*>& aArr) const -> void
{
mManagedPURLClassifierChild.ToArray(aArr);
}
auto PContentChild::ManagedPURLClassifierChild() const -> const ManagedContainer<PURLClassifierChild>&
{
return mManagedPURLClassifierChild;
}
auto PContentChild::ManagedPURLClassifierLocalChild(nsTArray<PURLClassifierLocalChild*>& aArr) const -> void
{
mManagedPURLClassifierLocalChild.ToArray(aArr);
}
auto PContentChild::ManagedPURLClassifierLocalChild() const -> const ManagedContainer<PURLClassifierLocalChild>&
{
return mManagedPURLClassifierLocalChild;
}
auto PContentChild::ManagedPScriptCacheChild(nsTArray<PScriptCacheChild*>& aArr) const -> void
{
mManagedPScriptCacheChild.ToArray(aArr);
}
auto PContentChild::ManagedPScriptCacheChild() const -> const ManagedContainer<PScriptCacheChild>&
{
return mManagedPScriptCacheChild;
}
auto PContentChild::ManagedPSessionStorageObserverChild(nsTArray<PSessionStorageObserverChild*>& aArr) const -> void
{
mManagedPSessionStorageObserverChild.ToArray(aArr);
}
auto PContentChild::ManagedPSessionStorageObserverChild() const -> const ManagedContainer<PSessionStorageObserverChild>&
{
return mManagedPSessionStorageObserverChild;
}
auto PContentChild::ManagedPBenchmarkStorageChild(nsTArray<PBenchmarkStorageChild*>& aArr) const -> void
{
mManagedPBenchmarkStorageChild.ToArray(aArr);
}
auto PContentChild::ManagedPBenchmarkStorageChild() const -> const ManagedContainer<PBenchmarkStorageChild>&
{
return mManagedPBenchmarkStorageChild;
}
auto PContentChild::ManagedProtocolIds() const -> mozilla::Span<mozilla::ipc::ProtocolId const>
{
static constexpr ::mozilla::ipc::ProtocolId sIds[] = {
PBrowserMsgStart,
PClipboardReadRequestMsgStart,
PClipboardWriteRequestMsgStart,
PContentPermissionRequestMsgStart,
PCycleCollectWithLogsMsgStart,
PExtensionsMsgStart,
PExternalHelperAppMsgStart,
PHalMsgStart,
PHandlerServiceMsgStart,
PHeapSnapshotTempFileHelperMsgStart,
PRemotePrintJobMsgStart,
PMediaMsgStart,
PNeckoMsgStart,
PSpeechSynthesisMsgStart,
PTestShellMsgStart,
PRemoteSpellcheckEngineMsgStart,
PWebBrowserPersistDocumentMsgStart,
PWebrtcGlobalMsgStart,
PURLClassifierMsgStart,
PURLClassifierLocalMsgStart,
PScriptCacheMsgStart,
PSessionStorageObserverMsgStart,
PBenchmarkStorageMsgStart
};
return sIds;
}
auto PContentChild::GetManagedActors(mozilla::ipc::ProtocolId aProtocol) -> UntypedManagedContainer*
{
switch (aProtocol) {
case PBrowserMsgStart:
return (&(mManagedPBrowserChild));
case PClipboardReadRequestMsgStart:
return (&(mManagedPClipboardReadRequestChild));
case PClipboardWriteRequestMsgStart:
return (&(mManagedPClipboardWriteRequestChild));
case PContentPermissionRequestMsgStart:
return (&(mManagedPContentPermissionRequestChild));
case PCycleCollectWithLogsMsgStart:
return (&(mManagedPCycleCollectWithLogsChild));
case PExtensionsMsgStart:
return (&(mManagedPExtensionsChild));
case PExternalHelperAppMsgStart:
return (&(mManagedPExternalHelperAppChild));
case PHalMsgStart:
return (&(mManagedPHalChild));
case PHandlerServiceMsgStart:
return (&(mManagedPHandlerServiceChild));
case PHeapSnapshotTempFileHelperMsgStart:
return (&(mManagedPHeapSnapshotTempFileHelperChild));
case PRemotePrintJobMsgStart:
return (&(mManagedPRemotePrintJobChild));
case PMediaMsgStart:
return (&(mManagedPMediaChild));
case PNeckoMsgStart:
return (&(mManagedPNeckoChild));
case PSpeechSynthesisMsgStart:
return (&(mManagedPSpeechSynthesisChild));
case PTestShellMsgStart:
return (&(mManagedPTestShellChild));
case PRemoteSpellcheckEngineMsgStart:
return (&(mManagedPRemoteSpellcheckEngineChild));
case PWebBrowserPersistDocumentMsgStart:
return (&(mManagedPWebBrowserPersistDocumentChild));
case PWebrtcGlobalMsgStart:
return (&(mManagedPWebrtcGlobalChild));
case PURLClassifierMsgStart:
return (&(mManagedPURLClassifierChild));
case PURLClassifierLocalMsgStart:
return (&(mManagedPURLClassifierLocalChild));
case PScriptCacheMsgStart:
return (&(mManagedPScriptCacheChild));
case PSessionStorageObserverMsgStart:
return (&(mManagedPSessionStorageObserverChild));
case PBenchmarkStorageMsgStart:
return (&(mManagedPBenchmarkStorageChild));
default:
return nullptr;
}
}
auto PContentChild::OpenPBrowserEndpoint(PBrowserChild* aActor) -> ManagedEndpoint<PBrowserParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBrowserChild actor");
return ManagedEndpoint<PBrowserParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PBrowserChild actor");
return ManagedEndpoint<PBrowserParent>();
}
// 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<PBrowserParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPBrowserEndpoint(
ManagedEndpoint<PBrowserChild> aEndpoint,
PBrowserChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPClipboardReadRequestEndpoint(PClipboardReadRequestChild* aActor) -> ManagedEndpoint<PClipboardReadRequestParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PClipboardReadRequestChild actor");
return ManagedEndpoint<PClipboardReadRequestParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PClipboardReadRequestChild actor");
return ManagedEndpoint<PClipboardReadRequestParent>();
}
// 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<PClipboardReadRequestParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPClipboardReadRequestEndpoint(
ManagedEndpoint<PClipboardReadRequestChild> aEndpoint,
PClipboardReadRequestChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPClipboardWriteRequestEndpoint(PClipboardWriteRequestChild* aActor) -> ManagedEndpoint<PClipboardWriteRequestParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PClipboardWriteRequestChild actor");
return ManagedEndpoint<PClipboardWriteRequestParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PClipboardWriteRequestChild actor");
return ManagedEndpoint<PClipboardWriteRequestParent>();
}
// 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<PClipboardWriteRequestParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPClipboardWriteRequestEndpoint(
ManagedEndpoint<PClipboardWriteRequestChild> aEndpoint,
PClipboardWriteRequestChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPContentPermissionRequestEndpoint(PContentPermissionRequestChild* aActor) -> ManagedEndpoint<PContentPermissionRequestParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PContentPermissionRequestChild actor");
return ManagedEndpoint<PContentPermissionRequestParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PContentPermissionRequestChild actor");
return ManagedEndpoint<PContentPermissionRequestParent>();
}
// 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<PContentPermissionRequestParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPContentPermissionRequestEndpoint(
ManagedEndpoint<PContentPermissionRequestChild> aEndpoint,
PContentPermissionRequestChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPCycleCollectWithLogsEndpoint(PCycleCollectWithLogsChild* aActor) -> ManagedEndpoint<PCycleCollectWithLogsParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PCycleCollectWithLogsChild actor");
return ManagedEndpoint<PCycleCollectWithLogsParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PCycleCollectWithLogsChild actor");
return ManagedEndpoint<PCycleCollectWithLogsParent>();
}
// 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<PCycleCollectWithLogsParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPCycleCollectWithLogsEndpoint(
ManagedEndpoint<PCycleCollectWithLogsChild> aEndpoint,
PCycleCollectWithLogsChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPExtensionsEndpoint(PExtensionsChild* aActor) -> ManagedEndpoint<PExtensionsParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PExtensionsChild actor");
return ManagedEndpoint<PExtensionsParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PExtensionsChild actor");
return ManagedEndpoint<PExtensionsParent>();
}
// 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<PExtensionsParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPExtensionsEndpoint(
ManagedEndpoint<PExtensionsChild> aEndpoint,
PExtensionsChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPExternalHelperAppEndpoint(PExternalHelperAppChild* aActor) -> ManagedEndpoint<PExternalHelperAppParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PExternalHelperAppChild actor");
return ManagedEndpoint<PExternalHelperAppParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PExternalHelperAppChild actor");
return ManagedEndpoint<PExternalHelperAppParent>();
}
// 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<PExternalHelperAppParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPExternalHelperAppEndpoint(
ManagedEndpoint<PExternalHelperAppChild> aEndpoint,
PExternalHelperAppChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPHalEndpoint(PHalChild* aActor) -> ManagedEndpoint<PHalParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PHalChild actor");
return ManagedEndpoint<PHalParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PHalChild actor");
return ManagedEndpoint<PHalParent>();
}
// 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<PHalParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPHalEndpoint(
ManagedEndpoint<PHalChild> aEndpoint,
PHalChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPHandlerServiceEndpoint(PHandlerServiceChild* aActor) -> ManagedEndpoint<PHandlerServiceParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PHandlerServiceChild actor");
return ManagedEndpoint<PHandlerServiceParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PHandlerServiceChild actor");
return ManagedEndpoint<PHandlerServiceParent>();
}
// 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<PHandlerServiceParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPHandlerServiceEndpoint(
ManagedEndpoint<PHandlerServiceChild> aEndpoint,
PHandlerServiceChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPHeapSnapshotTempFileHelperEndpoint(PHeapSnapshotTempFileHelperChild* aActor) -> ManagedEndpoint<PHeapSnapshotTempFileHelperParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PHeapSnapshotTempFileHelperChild actor");
return ManagedEndpoint<PHeapSnapshotTempFileHelperParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PHeapSnapshotTempFileHelperChild actor");
return ManagedEndpoint<PHeapSnapshotTempFileHelperParent>();
}
// 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<PHeapSnapshotTempFileHelperParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPHeapSnapshotTempFileHelperEndpoint(
ManagedEndpoint<PHeapSnapshotTempFileHelperChild> aEndpoint,
PHeapSnapshotTempFileHelperChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPRemotePrintJobEndpoint(PRemotePrintJobChild* aActor) -> ManagedEndpoint<PRemotePrintJobParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PRemotePrintJobChild actor");
return ManagedEndpoint<PRemotePrintJobParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PRemotePrintJobChild actor");
return ManagedEndpoint<PRemotePrintJobParent>();
}
// 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<PRemotePrintJobParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPRemotePrintJobEndpoint(
ManagedEndpoint<PRemotePrintJobChild> aEndpoint,
PRemotePrintJobChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPMediaEndpoint(PMediaChild* aActor) -> ManagedEndpoint<PMediaParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PMediaChild actor");
return ManagedEndpoint<PMediaParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PMediaChild actor");
return ManagedEndpoint<PMediaParent>();
}
// 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<PMediaParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPMediaEndpoint(
ManagedEndpoint<PMediaChild> aEndpoint,
PMediaChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPNeckoEndpoint(PNeckoChild* aActor) -> ManagedEndpoint<PNeckoParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PNeckoChild actor");
return ManagedEndpoint<PNeckoParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PNeckoChild actor");
return ManagedEndpoint<PNeckoParent>();
}
// 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<PNeckoParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPNeckoEndpoint(
ManagedEndpoint<PNeckoChild> aEndpoint,
PNeckoChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPSpeechSynthesisEndpoint(PSpeechSynthesisChild* aActor) -> ManagedEndpoint<PSpeechSynthesisParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PSpeechSynthesisChild actor");
return ManagedEndpoint<PSpeechSynthesisParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PSpeechSynthesisChild actor");
return ManagedEndpoint<PSpeechSynthesisParent>();
}
// 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<PSpeechSynthesisParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPSpeechSynthesisEndpoint(
ManagedEndpoint<PSpeechSynthesisChild> aEndpoint,
PSpeechSynthesisChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPTestShellEndpoint(PTestShellChild* aActor) -> ManagedEndpoint<PTestShellParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PTestShellChild actor");
return ManagedEndpoint<PTestShellParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PTestShellChild actor");
return ManagedEndpoint<PTestShellParent>();
}
// 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<PTestShellParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPTestShellEndpoint(
ManagedEndpoint<PTestShellChild> aEndpoint,
PTestShellChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPRemoteSpellcheckEngineEndpoint(PRemoteSpellcheckEngineChild* aActor) -> ManagedEndpoint<PRemoteSpellcheckEngineParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PRemoteSpellcheckEngineChild actor");
return ManagedEndpoint<PRemoteSpellcheckEngineParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PRemoteSpellcheckEngineChild actor");
return ManagedEndpoint<PRemoteSpellcheckEngineParent>();
}
// 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<PRemoteSpellcheckEngineParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPRemoteSpellcheckEngineEndpoint(
ManagedEndpoint<PRemoteSpellcheckEngineChild> aEndpoint,
PRemoteSpellcheckEngineChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPWebBrowserPersistDocumentEndpoint(PWebBrowserPersistDocumentChild* aActor) -> ManagedEndpoint<PWebBrowserPersistDocumentParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWebBrowserPersistDocumentChild actor");
return ManagedEndpoint<PWebBrowserPersistDocumentParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PWebBrowserPersistDocumentChild actor");
return ManagedEndpoint<PWebBrowserPersistDocumentParent>();
}
// 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<PWebBrowserPersistDocumentParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPWebBrowserPersistDocumentEndpoint(
ManagedEndpoint<PWebBrowserPersistDocumentChild> aEndpoint,
PWebBrowserPersistDocumentChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPWebrtcGlobalEndpoint(PWebrtcGlobalChild* aActor) -> ManagedEndpoint<PWebrtcGlobalParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWebrtcGlobalChild actor");
return ManagedEndpoint<PWebrtcGlobalParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PWebrtcGlobalChild actor");
return ManagedEndpoint<PWebrtcGlobalParent>();
}
// 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<PWebrtcGlobalParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPWebrtcGlobalEndpoint(
ManagedEndpoint<PWebrtcGlobalChild> aEndpoint,
PWebrtcGlobalChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPURLClassifierEndpoint(PURLClassifierChild* aActor) -> ManagedEndpoint<PURLClassifierParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PURLClassifierChild actor");
return ManagedEndpoint<PURLClassifierParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PURLClassifierChild actor");
return ManagedEndpoint<PURLClassifierParent>();
}
// 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<PURLClassifierParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPURLClassifierEndpoint(
ManagedEndpoint<PURLClassifierChild> aEndpoint,
PURLClassifierChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPURLClassifierLocalEndpoint(PURLClassifierLocalChild* aActor) -> ManagedEndpoint<PURLClassifierLocalParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PURLClassifierLocalChild actor");
return ManagedEndpoint<PURLClassifierLocalParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PURLClassifierLocalChild actor");
return ManagedEndpoint<PURLClassifierLocalParent>();
}
// 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<PURLClassifierLocalParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPURLClassifierLocalEndpoint(
ManagedEndpoint<PURLClassifierLocalChild> aEndpoint,
PURLClassifierLocalChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPScriptCacheEndpoint(PScriptCacheChild* aActor) -> ManagedEndpoint<PScriptCacheParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PScriptCacheChild actor");
return ManagedEndpoint<PScriptCacheParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PScriptCacheChild actor");
return ManagedEndpoint<PScriptCacheParent>();
}
// 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<PScriptCacheParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPScriptCacheEndpoint(
ManagedEndpoint<PScriptCacheChild> aEndpoint,
PScriptCacheChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPSessionStorageObserverEndpoint(PSessionStorageObserverChild* aActor) -> ManagedEndpoint<PSessionStorageObserverParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PSessionStorageObserverChild actor");
return ManagedEndpoint<PSessionStorageObserverParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PSessionStorageObserverChild actor");
return ManagedEndpoint<PSessionStorageObserverParent>();
}
// 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<PSessionStorageObserverParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPSessionStorageObserverEndpoint(
ManagedEndpoint<PSessionStorageObserverChild> aEndpoint,
PSessionStorageObserverChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::OpenPBenchmarkStorageEndpoint(PBenchmarkStorageChild* aActor) -> ManagedEndpoint<PBenchmarkStorageParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBenchmarkStorageChild actor");
return ManagedEndpoint<PBenchmarkStorageParent>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PBenchmarkStorageChild actor");
return ManagedEndpoint<PBenchmarkStorageParent>();
}
// 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<PBenchmarkStorageParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentChild::BindPBenchmarkStorageEndpoint(
ManagedEndpoint<PBenchmarkStorageChild> aEndpoint,
PBenchmarkStorageChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentChild::SendConstructPopupBrowser(
ManagedEndpoint<::mozilla::dom::PBrowserParent>&& browserEp,
ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>&& windowEp,
const TabId& tabId,
const IPCTabContext& context,
const WindowGlobalInit& windowInit,
const uint32_t& chromeFlags) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ConstructPopupBrowser(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), std::move(browserEp));
// Sentinel = 'browserEp'
((&(writer__)))->WriteSentinel(318833594);
IPC::WriteParam((&(writer__)), std::move(windowEp));
// Sentinel = 'windowEp'
((&(writer__)))->WriteSentinel(255984462);
IPC::WriteParam((&(writer__)), tabId);
// Sentinel = 'tabId'
((&(writer__)))->WriteSentinel(99156453);
IPC::WriteParam((&(writer__)), context);
// Sentinel = 'context'
((&(writer__)))->WriteSentinel(199164678);
IPC::WriteParam((&(writer__)), windowInit);
// Sentinel = 'windowInit'
((&(writer__)))->WriteSentinel(388891693);
IPC::WriteParam((&(writer__)), chromeFlags);
// Sentinel = 'chromeFlags'
((&(writer__)))->WriteSentinel(446760044);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ConstructPopupBrowser", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendCloneDocumentTreeInto(
const MaybeDiscardedBrowsingContext& aSourceBc,
const MaybeDiscardedBrowsingContext& aTargetBc,
const PrintData& aPrintData) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CloneDocumentTreeInto(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aSourceBc);
// Sentinel = 'aSourceBc'
((&(writer__)))->WriteSentinel(296551288);
IPC::WriteParam((&(writer__)), aTargetBc);
// Sentinel = 'aTargetBc'
((&(writer__)))->WriteSentinel(289342318);
IPC::WriteParam((&(writer__)), aPrintData);
// Sentinel = 'aPrintData'
((&(writer__)))->WriteSentinel(359072745);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CloneDocumentTreeInto", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendUpdateRemotePrintSettings(
const MaybeDiscardedBrowsingContext& aBc,
const PrintData& aPrintData) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateRemotePrintSettings(MSG_ROUTING_CONTROL);
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("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateRemotePrintSettings", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendPExtensionsConstructor(PExtensionsChild* actor) -> PExtensionsChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PExtensionsChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PExtensionsChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PExtensionsConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PExtensionsConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PExtensionsChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendPWebBrowserPersistDocumentConstructor(
PWebBrowserPersistDocumentChild* actor,
PBrowserChild* aBrowser,
const MaybeDiscardedBrowsingContext& aContext) -> PWebBrowserPersistDocumentChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PWebBrowserPersistDocumentChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PWebBrowserPersistDocumentChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PWebBrowserPersistDocumentConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), aBrowser);
// Sentinel = 'aBrowser'
((&(writer__)))->WriteSentinel(237372230);
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PWebBrowserPersistDocumentConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PWebBrowserPersistDocumentChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendRawMessage(
const JSActorMessageMeta& aMetadata,
const mozilla::Maybe<ClonedMessageData>& aData,
const mozilla::Maybe<ClonedMessageData>& aStack) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RawMessage(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aMetadata);
// Sentinel = 'aMetadata'
((&(writer__)))->WriteSentinel(288752515);
IPC::WriteParam((&(writer__)), aData);
// Sentinel = 'aData'
((&(writer__)))->WriteSentinel(90571228);
IPC::WriteParam((&(writer__)), aStack);
// Sentinel = 'aStack'
((&(writer__)))->WriteSentinel(135201368);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RawMessage", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSynchronizeLayoutHistoryState(
const MaybeDiscardedBrowsingContext& aContext,
nsILayoutHistoryState* aState) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SynchronizeLayoutHistoryState(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aState);
// Sentinel = 'aState'
((&(writer__)))->WriteSentinel(137036387);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SynchronizeLayoutHistoryState", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSessionHistoryEntryTitle(
const MaybeDiscardedBrowsingContext& aContext,
const nsAString& aTitle) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SessionHistoryEntryTitle(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aTitle);
// Sentinel = 'aTitle'
((&(writer__)))->WriteSentinel(137167460);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryTitle", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSessionHistoryEntryScrollRestorationIsManual(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aIsManual) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SessionHistoryEntryScrollRestorationIsManual(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aIsManual);
// Sentinel = 'aIsManual'
((&(writer__)))->WriteSentinel(282526588);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryScrollRestorationIsManual", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSessionHistoryEntryScrollPosition(
const MaybeDiscardedBrowsingContext& aContext,
const int32_t& aX,
const int32_t& aY) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SessionHistoryEntryScrollPosition(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aX);
// Sentinel = 'aX'
((&(writer__)))->WriteSentinel(18612410);
IPC::WriteParam((&(writer__)), aY);
// Sentinel = 'aY'
((&(writer__)))->WriteSentinel(18677947);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryScrollPosition", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSessionHistoryEntryCacheKey(
const MaybeDiscardedBrowsingContext& aContext,
const uint32_t& aCacheKey) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SessionHistoryEntryCacheKey(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aCacheKey);
// Sentinel = 'aCacheKey'
((&(writer__)))->WriteSentinel(272827231);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryCacheKey", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSessionHistoryEntryStoreWindowNameInContiguousEntries(
const MaybeDiscardedBrowsingContext& aContext,
const nsAString& aName) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SessionHistoryEntryStoreWindowNameInContiguousEntries(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aName);
// Sentinel = 'aName'
((&(writer__)))->WriteSentinel(92537315);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryStoreWindowNameInContiguousEntries", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSessionHistoryEntryWireframe(
const MaybeDiscardedBrowsingContext& aContext,
const Wireframe& aWireframe) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SessionHistoryEntryWireframe(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aWireframe);
// Sentinel = 'aWireframe'
((&(writer__)))->WriteSentinel(365888516);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryWireframe", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendGetLoadingSessionHistoryInfoFromParent(
const MaybeDiscardedBrowsingContext& aContext,
mozilla::ipc::ResolveCallback<mozilla::Maybe<LoadingSessionHistoryInfo>>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GetLoadingSessionHistoryInfoFromParent(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetLoadingSessionHistoryInfoFromParent", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_GetLoadingSessionHistoryInfoFromParent__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendGetLoadingSessionHistoryInfoFromParent(const MaybeDiscardedBrowsingContext& aContext) -> RefPtr<GetLoadingSessionHistoryInfoFromParentPromise>
{
RefPtr<MozPromise<mozilla::Maybe<LoadingSessionHistoryInfo>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<mozilla::Maybe<LoadingSessionHistoryInfo>, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendGetLoadingSessionHistoryInfoFromParent(std::move(aContext), [promise__](mozilla::Maybe<LoadingSessionHistoryInfo>&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendRemoveFromBFCache(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RemoveFromBFCache(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RemoveFromBFCache", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendInitBackground(Endpoint<::mozilla::ipc::PBackgroundStarterParent>&& aEndpoint) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InitBackground(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), std::move(aEndpoint));
// Sentinel = 'aEndpoint'
((&(writer__)))->WriteSentinel(292225955);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitBackground", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendCreateGMPService() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateGMPService(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateGMPService", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendCreateClipboardContentAnalysis(Endpoint<::mozilla::PClipboardContentAnalysisParent>&& aParentEndpoint) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateClipboardContentAnalysis(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), std::move(aParentEndpoint));
// Sentinel = 'aParentEndpoint'
((&(writer__)))->WriteSentinel(789775885);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateClipboardContentAnalysis", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendInitStreamFilter(
const uint64_t& channelId,
const nsAString& addonId,
mozilla::ipc::ResolveCallback<Endpoint<::mozilla::extensions::PStreamFilterChild>>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InitStreamFilter(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), channelId);
// Sentinel = 'channelId'
((&(writer__)))->WriteSentinel(301138823);
IPC::WriteParam((&(writer__)), addonId);
// Sentinel = 'addonId'
((&(writer__)))->WriteSentinel(183894708);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitStreamFilter", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_InitStreamFilter__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendInitStreamFilter(
const uint64_t& channelId,
const nsAString& addonId) -> RefPtr<InitStreamFilterPromise>
{
RefPtr<MozPromise<Endpoint<::mozilla::extensions::PStreamFilterChild>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<Endpoint<::mozilla::extensions::PStreamFilterChild>, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendInitStreamFilter(std::move(channelId), std::move(addonId), [promise__](Endpoint<::mozilla::extensions::PStreamFilterChild>&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendPRemoteSpellcheckEngineConstructor() -> PRemoteSpellcheckEngineChild*
{
PRemoteSpellcheckEngineChild* actor = (static_cast<ContentChild*>(this))->AllocPRemoteSpellcheckEngineChild();
return SendPRemoteSpellcheckEngineConstructor(std::move(actor));
}
auto PContentChild::SendPRemoteSpellcheckEngineConstructor(PRemoteSpellcheckEngineChild* actor) -> PRemoteSpellcheckEngineChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PRemoteSpellcheckEngineChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PRemoteSpellcheckEngineChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PRemoteSpellcheckEngineConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PRemoteSpellcheckEngineConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PRemoteSpellcheckEngineChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendInitCrashReporter(const NativeThreadId& tid) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InitCrashReporter(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), tid);
// Sentinel = 'tid'
((&(writer__)))->WriteSentinel(43319618);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitCrashReporter", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendIsSecureURI(
nsIURI* aURI,
const OriginAttributes& aOriginAttributes,
bool* isSecureURI) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_IsSecureURI(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aURI);
// Sentinel = 'aURI'
((&(writer__)))->WriteSentinel(57934162);
IPC::WriteParam((&(writer__)), aOriginAttributes);
// Sentinel = 'aOriginAttributes'
((&(writer__)))->WriteSentinel(1021839089);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_IsSecureURI", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PContent::Msg_IsSecureURI", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__isSecureURI__reply = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__isSecureURI__reply) {
FatalError("Error deserializing 'bool'");
return false;
}
auto& isSecureURI__reply = *maybe__isSecureURI__reply;
// Sentinel = 'isSecureURI'
if ((!(((&(reader__)))->ReadSentinel(441189428)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return false;
}
(*(isSecureURI)) = std::move(isSecureURI__reply);
reader__.EndRead();
return true;
}
auto PContentChild::SendAccumulateMixedContentHSTS(
nsIURI* aURI,
const bool& aActive,
const OriginAttributes& aOriginAttributes) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AccumulateMixedContentHSTS(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aURI);
// Sentinel = 'aURI'
((&(writer__)))->WriteSentinel(57934162);
IPC::WriteParam((&(writer__)), aActive);
// Sentinel = 'aActive'
((&(writer__)))->WriteSentinel(176095934);
IPC::WriteParam((&(writer__)), aOriginAttributes);
// Sentinel = 'aOriginAttributes'
((&(writer__)))->WriteSentinel(1021839089);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AccumulateMixedContentHSTS", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendPHalConstructor() -> PHalChild*
{
PHalChild* actor = (static_cast<ContentChild*>(this))->AllocPHalChild();
return SendPHalConstructor(std::move(actor));
}
auto PContentChild::SendPHalConstructor(PHalChild* actor) -> PHalChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PHalChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PHalChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PHalConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PHalConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PHalChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendPHeapSnapshotTempFileHelperConstructor() -> PHeapSnapshotTempFileHelperChild*
{
PHeapSnapshotTempFileHelperChild* actor = (static_cast<ContentChild*>(this))->AllocPHeapSnapshotTempFileHelperChild();
return SendPHeapSnapshotTempFileHelperConstructor(std::move(actor));
}
auto PContentChild::SendPHeapSnapshotTempFileHelperConstructor(PHeapSnapshotTempFileHelperChild* actor) -> PHeapSnapshotTempFileHelperChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PHeapSnapshotTempFileHelperChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PHeapSnapshotTempFileHelperChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PHeapSnapshotTempFileHelperConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PHeapSnapshotTempFileHelperConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PHeapSnapshotTempFileHelperChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendPNeckoConstructor(PNeckoChild* actor) -> PNeckoChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PNeckoChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PNeckoChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PNeckoConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PNeckoConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PNeckoChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendPSpeechSynthesisConstructor(PSpeechSynthesisChild* actor) -> PSpeechSynthesisChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PSpeechSynthesisChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PSpeechSynthesisChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PSpeechSynthesisConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PSpeechSynthesisConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PSpeechSynthesisChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendPMediaConstructor() -> PMediaChild*
{
PMediaChild* actor = (static_cast<ContentChild*>(this))->AllocPMediaChild();
return SendPMediaConstructor(std::move(actor));
}
auto PContentChild::SendPMediaConstructor(PMediaChild* actor) -> PMediaChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PMediaChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PMediaChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PMediaConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PMediaConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PMediaChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendPWebrtcGlobalConstructor() -> PWebrtcGlobalChild*
{
PWebrtcGlobalChild* actor = (static_cast<ContentChild*>(this))->AllocPWebrtcGlobalChild();
return SendPWebrtcGlobalConstructor(std::move(actor));
}
auto PContentChild::SendPWebrtcGlobalConstructor(PWebrtcGlobalChild* actor) -> PWebrtcGlobalChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PWebrtcGlobalChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PWebrtcGlobalChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PWebrtcGlobalConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PWebrtcGlobalConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PWebrtcGlobalChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendCreateAudioIPCConnection(
mozilla::ipc::ResolveCallback<FileDescOrError>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateAudioIPCConnection(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateAudioIPCConnection", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_CreateAudioIPCConnection__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendCreateAudioIPCConnection() -> RefPtr<CreateAudioIPCConnectionPromise>
{
RefPtr<MozPromise<FileDescOrError, ResponseRejectReason, true>::Private> promise__ = new MozPromise<FileDescOrError, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendCreateAudioIPCConnection([promise__](FileDescOrError&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendPURLClassifierConstructor(
nsIPrincipal* principal,
bool* success) -> PURLClassifierChild*
{
PURLClassifierChild* actor = (static_cast<ContentChild*>(this))->AllocPURLClassifierChild(principal, success);
return SendPURLClassifierConstructor(std::move(actor), principal, success);
}
auto PContentChild::SendPURLClassifierConstructor(
PURLClassifierChild* actor,
nsIPrincipal* principal,
bool* success) -> PURLClassifierChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PURLClassifierChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PURLClassifierChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PURLClassifierConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
// Synchronously send the constructor message to the other side. If
// the send fails, e.g. due to the remote side shutting down, the
// actor will be destroyed and potentially freed.
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PURLClassifierConstructor", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PContent::Msg_PURLClassifierConstructor", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if (!(sendok__)) {
// Warn, destroy the actor and return null if the message
// failed to send.
NS_WARNING("Error sending constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__success__reply = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__success__reply) {
FatalError("Error deserializing 'bool'");
return nullptr;
}
auto& success__reply = *maybe__success__reply;
// Sentinel = 'success'
if ((!(((&(reader__)))->ReadSentinel(200082170)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return nullptr;
}
(*(success)) = std::move(success__reply);
reader__.EndRead();
return actor;
}
auto PContentChild::SendPURLClassifierLocalConstructor(
nsIURI* uri,
mozilla::Span<IPCURLClassifierFeature const> features) -> PURLClassifierLocalChild*
{
PURLClassifierLocalChild* actor = (static_cast<ContentChild*>(this))->AllocPURLClassifierLocalChild(uri, features);
return SendPURLClassifierLocalConstructor(std::move(actor), uri, std::move(features));
}
auto PContentChild::SendPURLClassifierLocalConstructor(
PURLClassifierLocalChild* actor,
nsIURI* uri,
mozilla::Span<IPCURLClassifierFeature const> features) -> PURLClassifierLocalChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PURLClassifierLocalChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PURLClassifierLocalChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PURLClassifierLocalConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), uri);
// Sentinel = 'uri'
((&(writer__)))->WriteSentinel(45023569);
IPC::WriteParam((&(writer__)), features);
// Sentinel = 'features'
((&(writer__)))->WriteSentinel(250348384);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PURLClassifierLocalConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PURLClassifierLocalChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendPSessionStorageObserverConstructor() -> PSessionStorageObserverChild*
{
PSessionStorageObserverChild* actor = (static_cast<ContentChild*>(this))->AllocPSessionStorageObserverChild();
return SendPSessionStorageObserverConstructor(std::move(actor));
}
auto PContentChild::SendPSessionStorageObserverConstructor(PSessionStorageObserverChild* actor) -> PSessionStorageObserverChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PSessionStorageObserverChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PSessionStorageObserverChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PSessionStorageObserverConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PSessionStorageObserverConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PSessionStorageObserverChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendPBenchmarkStorageConstructor() -> PBenchmarkStorageChild*
{
PBenchmarkStorageChild* actor = (static_cast<ContentChild*>(this))->AllocPBenchmarkStorageChild();
return SendPBenchmarkStorageConstructor(std::move(actor));
}
auto PContentChild::SendPBenchmarkStorageConstructor(PBenchmarkStorageChild* actor) -> PBenchmarkStorageChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PBenchmarkStorageChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PBenchmarkStorageChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PBenchmarkStorageConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PBenchmarkStorageConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PBenchmarkStorageChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendStartVisitedQueries(mozilla::Span<RefPtr<nsIURI> const> uri) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_StartVisitedQueries(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), uri);
// Sentinel = 'uri'
((&(writer__)))->WriteSentinel(45023569);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_StartVisitedQueries", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSetURITitle(
nsIURI* uri,
const nsAString& title) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetURITitle(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), uri);
// Sentinel = 'uri'
((&(writer__)))->WriteSentinel(45023569);
IPC::WriteParam((&(writer__)), title);
// Sentinel = 'title'
((&(writer__)))->WriteSentinel(109445667);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetURITitle", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendLoadURIExternal(
nsIURI* uri,
nsIPrincipal* triggeringPrincipal,
nsIPrincipal* redirectPrincipal,
const MaybeDiscardedBrowsingContext& browsingContext,
const bool& wasExternallyTriggered,
const bool& hasValidUserGestureActivation,
const bool& newWindowTarget) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_LoadURIExternal(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), uri);
// Sentinel = 'uri'
((&(writer__)))->WriteSentinel(45023569);
IPC::WriteParam((&(writer__)), triggeringPrincipal);
// Sentinel = 'triggeringPrincipal'
((&(writer__)))->WriteSentinel(1325729749);
IPC::WriteParam((&(writer__)), redirectPrincipal);
// Sentinel = 'redirectPrincipal'
((&(writer__)))->WriteSentinel(1052772085);
IPC::WriteParam((&(writer__)), browsingContext);
// Sentinel = 'browsingContext'
((&(writer__)))->WriteSentinel(844695121);
IPC::WriteParam((&(writer__)), wasExternallyTriggered);
// Sentinel = 'wasExternallyTriggered'
((&(writer__)))->WriteSentinel(1758005521);
IPC::WriteParam((&(writer__)), hasValidUserGestureActivation);
// Sentinel = 'hasValidUserGestureActivation'
((&(writer__)))->WriteSentinel(2914388925);
IPC::WriteParam((&(writer__)), newWindowTarget);
// Sentinel = 'newWindowTarget'
((&(writer__)))->WriteSentinel(826934826);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_LoadURIExternal", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendExtProtocolChannelConnectParent(const uint64_t& registrarId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ExtProtocolChannelConnectParent(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), registrarId);
// Sentinel = 'registrarId'
((&(writer__)))->WriteSentinel(464585857);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ExtProtocolChannelConnectParent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSyncMessage(
const nsAString& aMessage,
const ClonedMessageData& aData,
nsTArray<StructuredCloneData>* retval) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SyncMessage(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aMessage);
// Sentinel = 'aMessage'
((&(writer__)))->WriteSentinel(233440039);
IPC::WriteParam((&(writer__)), aData);
// Sentinel = 'aData'
((&(writer__)))->WriteSentinel(90571228);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SyncMessage", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PContent::Msg_SyncMessage", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__retval__reply = IPC::ReadParam<nsTArray<StructuredCloneData>>((&(reader__)));
if (!maybe__retval__reply) {
FatalError("Error deserializing 'StructuredCloneData[]'");
return false;
}
auto& retval__reply = *maybe__retval__reply;
// Sentinel = 'retval'
if ((!(((&(reader__)))->ReadSentinel(151716495)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'StructuredCloneData[]'");
return false;
}
(*(retval)) = std::move(retval__reply);
reader__.EndRead();
return true;
}
auto PContentChild::SendShowAlert(nsIAlertNotification* alert) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ShowAlert(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), alert);
// Sentinel = 'alert'
((&(writer__)))->WriteSentinel(102826521);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ShowAlert", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendCloseAlert(
const nsAString& name,
const bool& contextClosed) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CloseAlert(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), name);
// Sentinel = 'name'
((&(writer__)))->WriteSentinel(69075362);
IPC::WriteParam((&(writer__)), contextClosed);
// Sentinel = 'contextClosed'
((&(writer__)))->WriteSentinel(636749152);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CloseAlert", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendDisableNotifications(nsIPrincipal* principal) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_DisableNotifications(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_DisableNotifications", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendOpenNotificationSettings(nsIPrincipal* principal) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_OpenNotificationSettings(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_OpenNotificationSettings", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendAddSecurityState(
const MaybeDiscardedWindowContext& aContext,
const uint32_t& aStateFlags) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AddSecurityState(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aStateFlags);
// Sentinel = 'aStateFlags'
((&(writer__)))->WriteSentinel(428606544);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddSecurityState", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotificationEvent(
const nsAString& type,
const NotificationEventData& data) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotificationEvent(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), type);
// Sentinel = 'type'
((&(writer__)))->WriteSentinel(75760067);
IPC::WriteParam((&(writer__)), data);
// Sentinel = 'data'
((&(writer__)))->WriteSentinel(67109275);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotificationEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendPExternalHelperAppConstructor(
PExternalHelperAppChild* actor,
nsIURI* uri,
const LoadInfoArgs& loadInfoArgs,
const nsACString& aMimeContentType,
const nsACString& aContentDisposition,
const uint32_t& aContentDispositionHint,
const nsAString& aContentDispositionFilename,
const bool& aForceSave,
const int64_t& aContentLength,
const bool& aWasFileChannel,
nsIURI* aReferrer,
const MaybeDiscardedBrowsingContext& aContext) -> PExternalHelperAppChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PExternalHelperAppChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PExternalHelperAppChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PExternalHelperAppConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), uri);
// Sentinel = 'uri'
((&(writer__)))->WriteSentinel(45023569);
IPC::WriteParam((&(writer__)), loadInfoArgs);
// Sentinel = 'loadInfoArgs'
((&(writer__)))->WriteSentinel(514000058);
IPC::WriteParam((&(writer__)), aMimeContentType);
// Sentinel = 'aMimeContentType'
((&(writer__)))->WriteSentinel(888538727);
IPC::WriteParam((&(writer__)), aContentDisposition);
// Sentinel = 'aContentDisposition'
((&(writer__)))->WriteSentinel(1279461330);
IPC::WriteParam((&(writer__)), aContentDispositionHint);
// Sentinel = 'aContentDispositionHint'
((&(writer__)))->WriteSentinel(1865812325);
IPC::WriteParam((&(writer__)), aContentDispositionFilename);
// Sentinel = 'aContentDispositionFilename'
((&(writer__)))->WriteSentinel(2558331635);
IPC::WriteParam((&(writer__)), aForceSave);
// Sentinel = 'aForceSave'
((&(writer__)))->WriteSentinel(350946272);
IPC::WriteParam((&(writer__)), aContentLength);
// Sentinel = 'aContentLength'
((&(writer__)))->WriteSentinel(694158751);
IPC::WriteParam((&(writer__)), aWasFileChannel);
// Sentinel = 'aWasFileChannel'
((&(writer__)))->WriteSentinel(759367110);
IPC::WriteParam((&(writer__)), aReferrer);
// Sentinel = 'aReferrer'
((&(writer__)))->WriteSentinel(293340063);
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PExternalHelperAppConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PExternalHelperAppChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendPHandlerServiceConstructor(PHandlerServiceChild* actor) -> PHandlerServiceChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PHandlerServiceChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PHandlerServiceChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PHandlerServiceConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PHandlerServiceConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PHandlerServiceChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendAddGeolocationListener(const bool& highAccuracy) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AddGeolocationListener(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), highAccuracy);
// Sentinel = 'highAccuracy'
((&(writer__)))->WriteSentinel(513737932);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddGeolocationListener", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendRemoveGeolocationListener() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RemoveGeolocationListener(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RemoveGeolocationListener", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSetGeolocationHigherAccuracy(const bool& enable) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetGeolocationHigherAccuracy(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), enable);
// Sentinel = 'enable'
((&(writer__)))->WriteSentinel(141623912);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetGeolocationHigherAccuracy", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendConsoleMessage(const nsAString& message) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ConsoleMessage(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), message);
// Sentinel = 'message'
((&(writer__)))->WriteSentinel(197198566);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ConsoleMessage", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendScriptErrorWithStack(
const nsAString& message,
const nsACString& sourceName,
const uint32_t& lineNumber,
const uint32_t& colNumber,
const uint32_t& flags,
const nsACString& category,
const bool& isFromPrivateWindow,
const bool& isFromChromeContext,
const ClonedMessageData& stack) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ScriptErrorWithStack(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), message);
// Sentinel = 'message'
((&(writer__)))->WriteSentinel(197198566);
IPC::WriteParam((&(writer__)), sourceName);
// Sentinel = 'sourceName'
((&(writer__)))->WriteSentinel(387580947);
IPC::WriteParam((&(writer__)), lineNumber);
// Sentinel = 'lineNumber'
((&(writer__)))->WriteSentinel(374932498);
IPC::WriteParam((&(writer__)), colNumber);
// Sentinel = 'colNumber'
((&(writer__)))->WriteSentinel(304284584);
IPC::WriteParam((&(writer__)), flags);
// Sentinel = 'flags'
((&(writer__)))->WriteSentinel(102171150);
IPC::WriteParam((&(writer__)), category);
// Sentinel = 'category'
((&(writer__)))->WriteSentinel(247333727);
IPC::WriteParam((&(writer__)), isFromPrivateWindow);
// Sentinel = 'isFromPrivateWindow'
((&(writer__)))->WriteSentinel(1288964036);
IPC::WriteParam((&(writer__)), isFromChromeContext);
// Sentinel = 'isFromChromeContext'
((&(writer__)))->WriteSentinel(1269368756);
IPC::WriteParam((&(writer__)), stack);
// Sentinel = 'stack'
((&(writer__)))->WriteSentinel(107479575);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ScriptErrorWithStack", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSetClipboard(
IPCTransferable&& aTransferable,
const ClipboardType& aWhichClipboard,
const MaybeDiscardedWindowContext& aRequestingWindowContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetClipboard(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), std::move(aTransferable));
// Sentinel = 'aTransferable'
((&(writer__)))->WriteSentinel(609813819);
IPC::WriteParam((&(writer__)), aWhichClipboard);
// Sentinel = 'aWhichClipboard'
((&(writer__)))->WriteSentinel(776996325);
IPC::WriteParam((&(writer__)), aRequestingWindowContext);
// Sentinel = 'aRequestingWindowContext'
((&(writer__)))->WriteSentinel(2049051110);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetClipboard", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendGetClipboard(
mozilla::Span<nsCString const> aTypes,
const ClipboardType& aWhichClipboard,
const MaybeDiscardedWindowContext& aRequestingWindowContext,
IPCTransferableDataOrError* transferableDataOrError) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GetClipboard(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aTypes);
// Sentinel = 'aTypes'
((&(writer__)))->WriteSentinel(140575351);
IPC::WriteParam((&(writer__)), aWhichClipboard);
// Sentinel = 'aWhichClipboard'
((&(writer__)))->WriteSentinel(776996325);
IPC::WriteParam((&(writer__)), aRequestingWindowContext);
// Sentinel = 'aRequestingWindowContext'
((&(writer__)))->WriteSentinel(2049051110);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetClipboard", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PContent::Msg_GetClipboard", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__transferableDataOrError__reply = IPC::ReadParam<IPCTransferableDataOrError>((&(reader__)));
if (!maybe__transferableDataOrError__reply) {
FatalError("Error deserializing 'IPCTransferableDataOrError'");
return false;
}
auto& transferableDataOrError__reply = *maybe__transferableDataOrError__reply;
// Sentinel = 'transferableDataOrError'
if ((!(((&(reader__)))->ReadSentinel(1880557887)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCTransferableDataOrError'");
return false;
}
(*(transferableDataOrError)) = std::move(transferableDataOrError__reply);
reader__.EndRead();
return true;
}
auto PContentChild::SendGetClipboardDataSnapshot(
mozilla::Span<nsCString const> aTypes,
const ClipboardType& aWhichClipboard,
const MaybeDiscardedWindowContext& aRequestingWindowContext,
mozilla::NotNull<nsIPrincipal*> aRequestingPrincipal,
mozilla::ipc::ResolveCallback<ClipboardReadRequestOrError>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GetClipboardDataSnapshot(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aTypes);
// Sentinel = 'aTypes'
((&(writer__)))->WriteSentinel(140575351);
IPC::WriteParam((&(writer__)), aWhichClipboard);
// Sentinel = 'aWhichClipboard'
((&(writer__)))->WriteSentinel(776996325);
IPC::WriteParam((&(writer__)), aRequestingWindowContext);
// Sentinel = 'aRequestingWindowContext'
((&(writer__)))->WriteSentinel(2049051110);
IPC::WriteParam((&(writer__)), aRequestingPrincipal);
// Sentinel = 'aRequestingPrincipal'
((&(writer__)))->WriteSentinel(1431439403);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetClipboardDataSnapshot", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_GetClipboardDataSnapshot__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendGetClipboardDataSnapshot(
mozilla::Span<nsCString const> aTypes,
const ClipboardType& aWhichClipboard,
const MaybeDiscardedWindowContext& aRequestingWindowContext,
mozilla::NotNull<nsIPrincipal*> aRequestingPrincipal) -> RefPtr<GetClipboardDataSnapshotPromise>
{
RefPtr<MozPromise<ClipboardReadRequestOrError, ResponseRejectReason, true>::Private> promise__ = new MozPromise<ClipboardReadRequestOrError, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendGetClipboardDataSnapshot(std::move(aTypes), std::move(aWhichClipboard), std::move(aRequestingWindowContext), std::move(aRequestingPrincipal), [promise__](ClipboardReadRequestOrError&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendGetClipboardDataSnapshotSync(
mozilla::Span<nsCString const> aTypes,
const ClipboardType& aWhichClipboard,
const MaybeDiscardedWindowContext& aRequestingWindowContext,
ClipboardReadRequestOrError* aClipboardReadRequestOrError) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GetClipboardDataSnapshotSync(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aTypes);
// Sentinel = 'aTypes'
((&(writer__)))->WriteSentinel(140575351);
IPC::WriteParam((&(writer__)), aWhichClipboard);
// Sentinel = 'aWhichClipboard'
((&(writer__)))->WriteSentinel(776996325);
IPC::WriteParam((&(writer__)), aRequestingWindowContext);
// Sentinel = 'aRequestingWindowContext'
((&(writer__)))->WriteSentinel(2049051110);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetClipboardDataSnapshotSync", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PContent::Msg_GetClipboardDataSnapshotSync", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__aClipboardReadRequestOrError__reply = IPC::ReadParam<ClipboardReadRequestOrError>((&(reader__)));
if (!maybe__aClipboardReadRequestOrError__reply) {
FatalError("Error deserializing 'ClipboardReadRequestOrError'");
return false;
}
auto& aClipboardReadRequestOrError__reply = *maybe__aClipboardReadRequestOrError__reply;
// Sentinel = 'aClipboardReadRequestOrError'
if ((!(((&(reader__)))->ReadSentinel(2662402850)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardReadRequestOrError'");
return false;
}
(*(aClipboardReadRequestOrError)) = std::move(aClipboardReadRequestOrError__reply);
reader__.EndRead();
return true;
}
auto PContentChild::SendEmptyClipboard(const ClipboardType& aWhichClipboard) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_EmptyClipboard(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aWhichClipboard);
// Sentinel = 'aWhichClipboard'
((&(writer__)))->WriteSentinel(776996325);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_EmptyClipboard", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendClipboardHasType(
mozilla::Span<nsCString const> aTypes,
const ClipboardType& aWhichClipboard,
bool* hasType) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ClipboardHasType(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aTypes);
// Sentinel = 'aTypes'
((&(writer__)))->WriteSentinel(140575351);
IPC::WriteParam((&(writer__)), aWhichClipboard);
// Sentinel = 'aWhichClipboard'
((&(writer__)))->WriteSentinel(776996325);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClipboardHasType", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PContent::Msg_ClipboardHasType", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__hasType__reply = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__hasType__reply) {
FatalError("Error deserializing 'bool'");
return false;
}
auto& hasType__reply = *maybe__hasType__reply;
// Sentinel = 'hasType'
if ((!(((&(reader__)))->ReadSentinel(191103711)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return false;
}
(*(hasType)) = std::move(hasType__reply);
reader__.EndRead();
return true;
}
auto PContentChild::SendPClipboardWriteRequestConstructor(
PClipboardWriteRequestChild* actor,
const ClipboardType& aClipboardType,
const MaybeDiscardedWindowContext& aSettingWindowContext) -> PClipboardWriteRequestChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PClipboardWriteRequestChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PClipboardWriteRequestChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PClipboardWriteRequestConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), aClipboardType);
// Sentinel = 'aClipboardType'
((&(writer__)))->WriteSentinel(686228884);
IPC::WriteParam((&(writer__)), aSettingWindowContext);
// Sentinel = 'aSettingWindowContext'
((&(writer__)))->WriteSentinel(1561659549);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PClipboardWriteRequestConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PClipboardWriteRequestChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendGetIconForExtension(
const nsACString& aFileExt,
const uint32_t& aIconSize,
nsTArray<uint8_t>* bits) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GetIconForExtension(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aFileExt);
// Sentinel = 'aFileExt'
((&(writer__)))->WriteSentinel(223544083);
IPC::WriteParam((&(writer__)), aIconSize);
// Sentinel = 'aIconSize'
((&(writer__)))->WriteSentinel(286196614);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetIconForExtension", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PContent::Msg_GetIconForExtension", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__bits__reply = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__bits__reply) {
FatalError("Error deserializing 'uint8_t[]'");
return false;
}
auto& bits__reply = *maybe__bits__reply;
// Sentinel = 'bits'
if ((!(((&(reader__)))->ReadSentinel(69337523)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return false;
}
(*(bits)) = std::move(bits__reply);
reader__.EndRead();
return true;
}
auto PContentChild::SendFirstIdle() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_FirstIdle(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_FirstIdle", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendCopyFavicon(
nsIURI* oldURI,
nsIURI* newURI,
const bool& isPrivate) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CopyFavicon(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), oldURI);
// Sentinel = 'oldURI'
((&(writer__)))->WriteSentinel(137888304);
IPC::WriteParam((&(writer__)), newURI);
// Sentinel = 'newURI'
((&(writer__)))->WriteSentinel(140182075);
IPC::WriteParam((&(writer__)), isPrivate);
// Sentinel = 'isPrivate'
((&(writer__)))->WriteSentinel(310576056);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CopyFavicon", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendFindImageText(
IPCImage&& image,
mozilla::Span<nsCString const> languages,
mozilla::ipc::ResolveCallback<TextRecognitionResultOrError>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_FindImageText(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), std::move(image));
// Sentinel = 'image'
((&(writer__)))->WriteSentinel(102498820);
IPC::WriteParam((&(writer__)), languages);
// Sentinel = 'languages'
((&(writer__)))->WriteSentinel(310903736);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_FindImageText", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_FindImageText__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendFindImageText(
IPCImage&& image,
mozilla::Span<nsCString const> languages) -> RefPtr<FindImageTextPromise>
{
RefPtr<MozPromise<TextRecognitionResultOrError, ResponseRejectReason, true>::Private> promise__ = new MozPromise<TextRecognitionResultOrError, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendFindImageText(std::move(image), std::move(languages), [promise__](TextRecognitionResultOrError&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendGraphicsError(const nsACString& aError) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GraphicsError(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aError);
// Sentinel = 'aError'
((&(writer__)))->WriteSentinel(135463532);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GraphicsError", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendBeginDriverCrashGuard(
const uint32_t& aGuardType,
bool* crashDetected) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_BeginDriverCrashGuard(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aGuardType);
// Sentinel = 'aGuardType'
((&(writer__)))->WriteSentinel(356647927);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_BeginDriverCrashGuard", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PContent::Msg_BeginDriverCrashGuard", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__crashDetected__reply = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__crashDetected__reply) {
FatalError("Error deserializing 'bool'");
return false;
}
auto& crashDetected__reply = *maybe__crashDetected__reply;
// Sentinel = 'crashDetected'
if ((!(((&(reader__)))->ReadSentinel(610731316)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return false;
}
(*(crashDetected)) = std::move(crashDetected__reply);
reader__.EndRead();
return true;
}
auto PContentChild::SendEndDriverCrashGuard(const uint32_t& aGuardType) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_EndDriverCrashGuard(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aGuardType);
// Sentinel = 'aGuardType'
((&(writer__)))->WriteSentinel(356647927);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_EndDriverCrashGuard", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PContent::Msg_EndDriverCrashGuard", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
return true;
}
auto PContentChild::SendAddIdleObserver(
const uint64_t& observerId,
const uint32_t& idleTimeInS) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AddIdleObserver(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), observerId);
// Sentinel = 'observerId'
((&(writer__)))->WriteSentinel(386335766);
IPC::WriteParam((&(writer__)), idleTimeInS);
// Sentinel = 'idleTimeInS'
((&(writer__)))->WriteSentinel(434832440);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddIdleObserver", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendRemoveIdleObserver(
const uint64_t& observerId,
const uint32_t& idleTimeInS) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RemoveIdleObserver(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), observerId);
// Sentinel = 'observerId'
((&(writer__)))->WriteSentinel(386335766);
IPC::WriteParam((&(writer__)), idleTimeInS);
// Sentinel = 'idleTimeInS'
((&(writer__)))->WriteSentinel(434832440);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RemoveIdleObserver", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendBackUpXResources(const FileDescriptor& aXSocketFd) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_BackUpXResources(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aXSocketFd);
// Sentinel = 'aXSocketFd'
((&(writer__)))->WriteSentinel(349569997);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_BackUpXResources", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendRequestAnonymousTemporaryFile(const uint64_t& aID) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RequestAnonymousTemporaryFile(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aID);
// Sentinel = 'aID'
((&(writer__)))->WriteSentinel(33292527);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RequestAnonymousTemporaryFile", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyShutdownSuccess() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyShutdownSuccess(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyShutdownSuccess", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendFinishShutdown() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_FinishShutdown(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_FinishShutdown", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendPContentPermissionRequestConstructor(
mozilla::Span<PermissionRequest const> aRequests,
nsIPrincipal* aPrincipal,
nsIPrincipal* aTopLevelPrincipal,
const bool& aIsHandlingUserInput,
const bool& aMaybeUnsafePermissionDelegate,
const TabId& tabId) -> PContentPermissionRequestChild*
{
PContentPermissionRequestChild* actor = (static_cast<ContentChild*>(this))->AllocPContentPermissionRequestChild(aRequests, aPrincipal, aTopLevelPrincipal, aIsHandlingUserInput, aMaybeUnsafePermissionDelegate, tabId);
return SendPContentPermissionRequestConstructor(std::move(actor), std::move(aRequests), aPrincipal, aTopLevelPrincipal, std::move(aIsHandlingUserInput), std::move(aMaybeUnsafePermissionDelegate), std::move(tabId));
}
auto PContentChild::SendPContentPermissionRequestConstructor(
PContentPermissionRequestChild* actor,
mozilla::Span<PermissionRequest const> aRequests,
nsIPrincipal* aPrincipal,
nsIPrincipal* aTopLevelPrincipal,
const bool& aIsHandlingUserInput,
const bool& aMaybeUnsafePermissionDelegate,
const TabId& tabId) -> PContentPermissionRequestChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PContentPermissionRequestChild actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PContentPermissionRequestChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PContentPermissionRequestConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), aRequests);
// Sentinel = 'aRequests'
((&(writer__)))->WriteSentinel(301728702);
IPC::WriteParam((&(writer__)), aPrincipal);
// Sentinel = 'aPrincipal'
((&(writer__)))->WriteSentinel(364381188);
IPC::WriteParam((&(writer__)), aTopLevelPrincipal);
// Sentinel = 'aTopLevelPrincipal'
((&(writer__)))->WriteSentinel(1128007471);
IPC::WriteParam((&(writer__)), aIsHandlingUserInput);
// Sentinel = 'aIsHandlingUserInput'
((&(writer__)))->WriteSentinel(1357514738);
IPC::WriteParam((&(writer__)), aMaybeUnsafePermissionDelegate);
// Sentinel = 'aMaybeUnsafePermissionDelegate'
((&(writer__)))->WriteSentinel(3078949878);
IPC::WriteParam((&(writer__)), tabId);
// Sentinel = 'tabId'
((&(writer__)))->WriteSentinel(99156453);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PContentPermissionRequestConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PContentPermissionRequestChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentChild::SendShutdownProfile(const nsACString& aProfile) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ShutdownProfile(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aProfile);
// Sentinel = 'aProfile'
((&(writer__)))->WriteSentinel(237437747);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ShutdownProfile", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendShutdownPerfStats(const nsACString& aPerfStats) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ShutdownPerfStats(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPerfStats);
// Sentinel = 'aPerfStats'
((&(writer__)))->WriteSentinel(356189182);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ShutdownPerfStats", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendGetFontListShmBlock(
const uint32_t& aGeneration,
const uint32_t& aIndex,
SharedMemoryHandle* aHandle) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GetFontListShmBlock(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aGeneration);
// Sentinel = 'aGeneration'
((&(writer__)))->WriteSentinel(430179438);
IPC::WriteParam((&(writer__)), aIndex);
// Sentinel = 'aIndex'
((&(writer__)))->WriteSentinel(132055642);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetFontListShmBlock", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PContent::Msg_GetFontListShmBlock", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__aHandle__reply = IPC::ReadParam<SharedMemoryHandle>((&(reader__)));
if (!maybe__aHandle__reply) {
FatalError("Error deserializing 'SharedMemoryHandle'");
return false;
}
auto& aHandle__reply = *maybe__aHandle__reply;
// Sentinel = 'aHandle'
if ((!(((&(reader__)))->ReadSentinel(174326446)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SharedMemoryHandle'");
return false;
}
(*(aHandle)) = std::move(aHandle__reply);
reader__.EndRead();
return true;
}
auto PContentChild::SendInitializeFamily(
const uint32_t& aGeneration,
const uint32_t& aFamilyIndex,
const bool& aLoadCmaps) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InitializeFamily(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aGeneration);
// Sentinel = 'aGeneration'
((&(writer__)))->WriteSentinel(430179438);
IPC::WriteParam((&(writer__)), aFamilyIndex);
// Sentinel = 'aFamilyIndex'
((&(writer__)))->WriteSentinel(501089468);
IPC::WriteParam((&(writer__)), aLoadCmaps);
// Sentinel = 'aLoadCmaps'
((&(writer__)))->WriteSentinel(342885334);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitializeFamily", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PContent::Msg_InitializeFamily", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
return true;
}
auto PContentChild::SendSetCharacterMap(
const uint32_t& aGeneration,
const uint32_t& aFamilyIndex,
const bool& aAlias,
const uint32_t& aFaceIndex,
const gfxSparseBitSet& aMap) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetCharacterMap(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aGeneration);
// Sentinel = 'aGeneration'
((&(writer__)))->WriteSentinel(430179438);
IPC::WriteParam((&(writer__)), aFamilyIndex);
// Sentinel = 'aFamilyIndex'
((&(writer__)))->WriteSentinel(501089468);
IPC::WriteParam((&(writer__)), aAlias);
// Sentinel = 'aAlias'
((&(writer__)))->WriteSentinel(129040972);
IPC::WriteParam((&(writer__)), aFaceIndex);
// Sentinel = 'aFaceIndex'
((&(writer__)))->WriteSentinel(335021001);
IPC::WriteParam((&(writer__)), aMap);
// Sentinel = 'aMap'
((&(writer__)))->WriteSentinel(60883328);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetCharacterMap", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSetupFamilyCharMap(
const uint32_t& aGeneration,
const uint32_t& aFamilyIndex,
const bool& aAlias) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetupFamilyCharMap(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aGeneration);
// Sentinel = 'aGeneration'
((&(writer__)))->WriteSentinel(430179438);
IPC::WriteParam((&(writer__)), aFamilyIndex);
// Sentinel = 'aFamilyIndex'
((&(writer__)))->WriteSentinel(501089468);
IPC::WriteParam((&(writer__)), aAlias);
// Sentinel = 'aAlias'
((&(writer__)))->WriteSentinel(129040972);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetupFamilyCharMap", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendInitOtherFamilyNames(
const uint32_t& aGeneration,
const bool& aDefer,
bool* aLoaded) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InitOtherFamilyNames(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aGeneration);
// Sentinel = 'aGeneration'
((&(writer__)))->WriteSentinel(430179438);
IPC::WriteParam((&(writer__)), aDefer);
// Sentinel = 'aDefer'
((&(writer__)))->WriteSentinel(128057928);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitOtherFamilyNames", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PContent::Msg_InitOtherFamilyNames", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__aLoaded__reply = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aLoaded__reply) {
FatalError("Error deserializing 'bool'");
return false;
}
auto& aLoaded__reply = *maybe__aLoaded__reply;
// Sentinel = 'aLoaded'
if ((!(((&(reader__)))->ReadSentinel(176095915)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return false;
}
(*(aLoaded)) = std::move(aLoaded__reply);
reader__.EndRead();
return true;
}
auto PContentChild::SendStartCmapLoading(
const uint32_t& aGeneration,
const uint32_t& aStartIndex) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_StartCmapLoading(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aGeneration);
// Sentinel = 'aGeneration'
((&(writer__)))->WriteSentinel(430179438);
IPC::WriteParam((&(writer__)), aStartIndex);
// Sentinel = 'aStartIndex'
((&(writer__)))->WriteSentinel(435749992);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_StartCmapLoading", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendGetHyphDict(
nsIURI* aURI,
SharedMemoryHandle* aHandle,
uint32_t* aSize) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GetHyphDict(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aURI);
// Sentinel = 'aURI'
((&(writer__)))->WriteSentinel(57934162);
UniquePtr<Message> reply__;
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetHyphDict", OTHER);
bool sendok__ = false;
{
AUTO_PROFILER_TRACING_MARKER("Sync IPC", "PContent::Msg_GetHyphDict", IPC);
sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
}
if ((!(sendok__))) {
return false;
}
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
IPC::MessageReader reader__{
(*(reply__)),
this};
auto maybe__aHandle__reply = IPC::ReadParam<SharedMemoryHandle>((&(reader__)));
if (!maybe__aHandle__reply) {
FatalError("Error deserializing 'SharedMemoryHandle'");
return false;
}
auto& aHandle__reply = *maybe__aHandle__reply;
// Sentinel = 'aHandle'
if ((!(((&(reader__)))->ReadSentinel(174326446)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SharedMemoryHandle'");
return false;
}
auto maybe__aSize__reply = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aSize__reply) {
FatalError("Error deserializing 'uint32_t'");
return false;
}
auto& aSize__reply = *maybe__aSize__reply;
// Sentinel = 'aSize'
if ((!(((&(reader__)))->ReadSentinel(97124861)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return false;
}
(*(aHandle)) = std::move(aHandle__reply);
(*(aSize)) = std::move(aSize__reply);
reader__.EndRead();
return true;
}
auto PContentChild::SendCreateWindow(
mozilla::NotNull<PBrowserChild*> aThisTab,
const MaybeDiscardedBrowsingContext& aParent,
mozilla::NotNull<PBrowserChild*> aNewTab,
const uint32_t& aChromeFlags,
const bool& aCalledFromJS,
const bool& aForPrinting,
const bool& aForWindowDotPrint,
const bool& aTopLevelCreatedByContent,
nsIURI* aURIToLoad,
const nsACString& aFeatures,
const Modifiers& aModifiers,
nsIPrincipal* aTriggeringPrincipal,
nsIContentSecurityPolicy* aCsp,
nsIReferrerInfo* aReferrerInfo,
const OriginAttributes& aOriginAttributes,
const bool& aUserActivation,
const bool& aTextDirectiveUserActivation,
mozilla::ipc::ResolveCallback<CreatedWindowInfo>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateWindow(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aThisTab);
// Sentinel = 'aThisTab'
((&(writer__)))->WriteSentinel(231015185);
IPC::WriteParam((&(writer__)), aParent);
// Sentinel = 'aParent'
((&(writer__)))->WriteSentinel(179962572);
IPC::WriteParam((&(writer__)), aNewTab);
// Sentinel = 'aNewTab'
((&(writer__)))->WriteSentinel(175571619);
IPC::WriteParam((&(writer__)), aChromeFlags);
// Sentinel = 'aChromeFlags'
((&(writer__)))->WriteSentinel(500040877);
IPC::WriteParam((&(writer__)), aCalledFromJS);
// Sentinel = 'aCalledFromJS'
((&(writer__)))->WriteSentinel(569967832);
IPC::WriteParam((&(writer__)), aForPrinting);
// Sentinel = 'aForPrinting'
((&(writer__)))->WriteSentinel(511313108);
IPC::WriteParam((&(writer__)), aForWindowDotPrint);
// Sentinel = 'aForWindowDotPrint'
((&(writer__)))->WriteSentinel(1123813173);
IPC::WriteParam((&(writer__)), aTopLevelCreatedByContent);
// Sentinel = 'aTopLevelCreatedByContent'
((&(writer__)))->WriteSentinel(2117143003);
IPC::WriteParam((&(writer__)), aURIToLoad);
// Sentinel = 'aURIToLoad'
((&(writer__)))->WriteSentinel(321258389);
IPC::WriteParam((&(writer__)), aFeatures);
// Sentinel = 'aFeatures'
((&(writer__)))->WriteSentinel(290849697);
IPC::WriteParam((&(writer__)), aModifiers);
// Sentinel = 'aModifiers'
((&(writer__)))->WriteSentinel(358286340);
IPC::WriteParam((&(writer__)), aTriggeringPrincipal);
// Sentinel = 'aTriggeringPrincipal'
((&(writer__)))->WriteSentinel(1413089302);
IPC::WriteParam((&(writer__)), aCsp);
// Sentinel = 'aCsp'
((&(writer__)))->WriteSentinel(61276552);
IPC::WriteParam((&(writer__)), aReferrerInfo);
// Sentinel = 'aReferrerInfo'
((&(writer__)))->WriteSentinel(597755179);
IPC::WriteParam((&(writer__)), aOriginAttributes);
// Sentinel = 'aOriginAttributes'
((&(writer__)))->WriteSentinel(1021839089);
IPC::WriteParam((&(writer__)), aUserActivation);
// Sentinel = 'aUserActivation'
((&(writer__)))->WriteSentinel(794887699);
IPC::WriteParam((&(writer__)), aTextDirectiveUserActivation);
// Sentinel = 'aTextDirectiveUserActivation'
((&(writer__)))->WriteSentinel(2721450839);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateWindow", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_CreateWindow__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendCreateWindow(
mozilla::NotNull<PBrowserChild*> aThisTab,
const MaybeDiscardedBrowsingContext& aParent,
mozilla::NotNull<PBrowserChild*> aNewTab,
const uint32_t& aChromeFlags,
const bool& aCalledFromJS,
const bool& aForPrinting,
const bool& aForWindowDotPrint,
const bool& aTopLevelCreatedByContent,
nsIURI* aURIToLoad,
const nsACString& aFeatures,
const Modifiers& aModifiers,
nsIPrincipal* aTriggeringPrincipal,
nsIContentSecurityPolicy* aCsp,
nsIReferrerInfo* aReferrerInfo,
const OriginAttributes& aOriginAttributes,
const bool& aUserActivation,
const bool& aTextDirectiveUserActivation) -> RefPtr<CreateWindowPromise>
{
RefPtr<MozPromise<CreatedWindowInfo, ResponseRejectReason, true>::Private> promise__ = new MozPromise<CreatedWindowInfo, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendCreateWindow(std::move(aThisTab), std::move(aParent), std::move(aNewTab), std::move(aChromeFlags), std::move(aCalledFromJS), std::move(aForPrinting), std::move(aForWindowDotPrint), std::move(aTopLevelCreatedByContent), std::move(aURIToLoad), std::move(aFeatures), std::move(aModifiers), std::move(aTriggeringPrincipal), std::move(aCsp), std::move(aReferrerInfo), std::move(aOriginAttributes), std::move(aUserActivation), std::move(aTextDirectiveUserActivation), [promise__](CreatedWindowInfo&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendCreateWindowInDifferentProcess(
mozilla::NotNull<PBrowserChild*> aThisTab,
const MaybeDiscardedBrowsingContext& aParent,
const uint32_t& aChromeFlags,
const bool& aCalledFromJS,
const bool& aTopLevelCreatedByContent,
nsIURI* aURIToLoad,
const nsACString& aFeatures,
const Modifiers& aModifiers,
const nsAString& aName,
nsIPrincipal* aTriggeringPrincipal,
nsIContentSecurityPolicy* aCsp,
nsIReferrerInfo* aReferrerInfo,
const OriginAttributes& aOriginAttributes,
const bool& aUserActivation,
const bool& aTextDirectiveUserActivation) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateWindowInDifferentProcess(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aThisTab);
// Sentinel = 'aThisTab'
((&(writer__)))->WriteSentinel(231015185);
IPC::WriteParam((&(writer__)), aParent);
// Sentinel = 'aParent'
((&(writer__)))->WriteSentinel(179962572);
IPC::WriteParam((&(writer__)), aChromeFlags);
// Sentinel = 'aChromeFlags'
((&(writer__)))->WriteSentinel(500040877);
IPC::WriteParam((&(writer__)), aCalledFromJS);
// Sentinel = 'aCalledFromJS'
((&(writer__)))->WriteSentinel(569967832);
IPC::WriteParam((&(writer__)), aTopLevelCreatedByContent);
// Sentinel = 'aTopLevelCreatedByContent'
((&(writer__)))->WriteSentinel(2117143003);
IPC::WriteParam((&(writer__)), aURIToLoad);
// Sentinel = 'aURIToLoad'
((&(writer__)))->WriteSentinel(321258389);
IPC::WriteParam((&(writer__)), aFeatures);
// Sentinel = 'aFeatures'
((&(writer__)))->WriteSentinel(290849697);
IPC::WriteParam((&(writer__)), aModifiers);
// Sentinel = 'aModifiers'
((&(writer__)))->WriteSentinel(358286340);
IPC::WriteParam((&(writer__)), aName);
// Sentinel = 'aName'
((&(writer__)))->WriteSentinel(92537315);
IPC::WriteParam((&(writer__)), aTriggeringPrincipal);
// Sentinel = 'aTriggeringPrincipal'
((&(writer__)))->WriteSentinel(1413089302);
IPC::WriteParam((&(writer__)), aCsp);
// Sentinel = 'aCsp'
((&(writer__)))->WriteSentinel(61276552);
IPC::WriteParam((&(writer__)), aReferrerInfo);
// Sentinel = 'aReferrerInfo'
((&(writer__)))->WriteSentinel(597755179);
IPC::WriteParam((&(writer__)), aOriginAttributes);
// Sentinel = 'aOriginAttributes'
((&(writer__)))->WriteSentinel(1021839089);
IPC::WriteParam((&(writer__)), aUserActivation);
// Sentinel = 'aUserActivation'
((&(writer__)))->WriteSentinel(794887699);
IPC::WriteParam((&(writer__)), aTextDirectiveUserActivation);
// Sentinel = 'aTextDirectiveUserActivation'
((&(writer__)))->WriteSentinel(2721450839);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateWindowInDifferentProcess", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyBenchmarkResult(
const nsAString& aCodecName,
const uint32_t& aDecodeFPS) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyBenchmarkResult(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aCodecName);
// Sentinel = 'aCodecName'
((&(writer__)))->WriteSentinel(340394945);
IPC::WriteParam((&(writer__)), aDecodeFPS);
// Sentinel = 'aDecodeFPS'
((&(writer__)))->WriteSentinel(335283087);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyBenchmarkResult", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyPushObservers(
const nsACString& scope,
nsIPrincipal* principal,
const nsAString& messageId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyPushObservers(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), scope);
// Sentinel = 'scope'
((&(writer__)))->WriteSentinel(107086363);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
IPC::WriteParam((&(writer__)), messageId);
// Sentinel = 'messageId'
((&(writer__)))->WriteSentinel(310576019);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushObservers", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyPushObserversWithData(
const nsACString& scope,
nsIPrincipal* principal,
const nsAString& messageId,
mozilla::Span<uint8_t const> data) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyPushObserversWithData(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), scope);
// Sentinel = 'scope'
((&(writer__)))->WriteSentinel(107086363);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
IPC::WriteParam((&(writer__)), messageId);
// Sentinel = 'messageId'
((&(writer__)))->WriteSentinel(310576019);
IPC::WriteParam((&(writer__)), data);
// Sentinel = 'data'
((&(writer__)))->WriteSentinel(67109275);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushObserversWithData", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyPushSubscriptionChangeObservers(
const nsACString& scope,
nsIPrincipal* principal) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyPushSubscriptionChangeObservers(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), scope);
// Sentinel = 'scope'
((&(writer__)))->WriteSentinel(107086363);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushSubscriptionChangeObservers", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendGetFilesRequest(
const nsID& aID,
const nsAString& aDirectory,
const bool& aRecursiveFlag) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GetFilesRequest(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aID);
// Sentinel = 'aID'
((&(writer__)))->WriteSentinel(33292527);
IPC::WriteParam((&(writer__)), aDirectory);
// Sentinel = 'aDirectory'
((&(writer__)))->WriteSentinel(358941719);
IPC::WriteParam((&(writer__)), aRecursiveFlag);
// Sentinel = 'aRecursiveFlag'
((&(writer__)))->WriteSentinel(701498772);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetFilesRequest", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendDeleteGetFilesRequest(const nsID& aID) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_DeleteGetFilesRequest(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aID);
// Sentinel = 'aID'
((&(writer__)))->WriteSentinel(33292527);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_DeleteGetFilesRequest", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendStoreAndBroadcastBlobURLRegistration(
const nsACString& url,
const IPCBlob& blob,
nsIPrincipal* principal,
const nsACString& aPartitionKey) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_StoreAndBroadcastBlobURLRegistration(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), url);
// Sentinel = 'url'
((&(writer__)))->WriteSentinel(45220180);
IPC::WriteParam((&(writer__)), blob);
// Sentinel = 'blob'
((&(writer__)))->WriteSentinel(68157856);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
IPC::WriteParam((&(writer__)), aPartitionKey);
// Sentinel = 'aPartitionKey'
((&(writer__)))->WriteSentinel(610141509);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_StoreAndBroadcastBlobURLRegistration", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendUnstoreAndBroadcastBlobURLUnregistration(
const nsACString& url,
nsIPrincipal* principal) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UnstoreAndBroadcastBlobURLUnregistration(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), url);
// Sentinel = 'url'
((&(writer__)))->WriteSentinel(45220180);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UnstoreAndBroadcastBlobURLUnregistration", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendRecordPageLoadEvent(const PageLoadExtra& event) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RecordPageLoadEvent(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), event);
// Sentinel = 'event'
((&(writer__)))->WriteSentinel(106234403);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RecordPageLoadEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendAccumulateChildHistograms(mozilla::Span<HistogramAccumulation const> accumulations) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AccumulateChildHistograms(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), accumulations);
// Sentinel = 'accumulations'
((&(writer__)))->WriteSentinel(632030585);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AccumulateChildHistograms", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendAccumulateChildKeyedHistograms(mozilla::Span<KeyedHistogramAccumulation const> accumulations) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AccumulateChildKeyedHistograms(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), accumulations);
// Sentinel = 'accumulations'
((&(writer__)))->WriteSentinel(632030585);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AccumulateChildKeyedHistograms", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendUpdateChildScalars(mozilla::Span<ScalarAction const> updates) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateChildScalars(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), updates);
// Sentinel = 'updates'
((&(writer__)))->WriteSentinel(199951095);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateChildScalars", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendUpdateChildKeyedScalars(mozilla::Span<KeyedScalarAction const> updates) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateChildKeyedScalars(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), updates);
// Sentinel = 'updates'
((&(writer__)))->WriteSentinel(199951095);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateChildKeyedScalars", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendRecordChildEvents(mozilla::Span<ChildEventData const> events) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RecordChildEvents(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), events);
// Sentinel = 'events'
((&(writer__)))->WriteSentinel(149619350);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RecordChildEvents", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendRecordDiscardedData(const DiscardedData& data) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RecordDiscardedData(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), data);
// Sentinel = 'data'
((&(writer__)))->WriteSentinel(67109275);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RecordDiscardedData", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendAddMemoryReport(const MemoryReport& aReport) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AddMemoryReport(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aReport);
// Sentinel = 'aReport'
((&(writer__)))->WriteSentinel(184025822);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddMemoryReport", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendBHRThreadHang(const HangDetails& aHangDetails) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_BHRThreadHang(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aHangDetails);
// Sentinel = 'aHangDetails'
((&(writer__)))->WriteSentinel(488113318);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_BHRThreadHang", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendAddCertException(
nsIX509Cert* aCert,
const nsACString& aHostName,
const int32_t& aPort,
const OriginAttributes& aOriginAttributes,
const bool& aIsTemporary,
mozilla::ipc::ResolveCallback<nsresult>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AddCertException(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aCert);
// Sentinel = 'aCert'
((&(writer__)))->WriteSentinel(92078576);
IPC::WriteParam((&(writer__)), aHostName);
// Sentinel = 'aHostName'
((&(writer__)))->WriteSentinel(290128769);
IPC::WriteParam((&(writer__)), aPort);
// Sentinel = 'aPort'
((&(writer__)))->WriteSentinel(97452551);
IPC::WriteParam((&(writer__)), aOriginAttributes);
// Sentinel = 'aOriginAttributes'
((&(writer__)))->WriteSentinel(1021839089);
IPC::WriteParam((&(writer__)), aIsTemporary);
// Sentinel = 'aIsTemporary'
((&(writer__)))->WriteSentinel(509805793);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddCertException", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_AddCertException__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendAddCertException(
nsIX509Cert* aCert,
const nsACString& aHostName,
const int32_t& aPort,
const OriginAttributes& aOriginAttributes,
const bool& aIsTemporary) -> RefPtr<AddCertExceptionPromise>
{
RefPtr<MozPromise<nsresult, ResponseRejectReason, true>::Private> promise__ = new MozPromise<nsresult, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendAddCertException(std::move(aCert), std::move(aHostName), std::move(aPort), std::move(aOriginAttributes), std::move(aIsTemporary), [promise__](nsresult&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendAutomaticStorageAccessPermissionCanBeGranted(
nsIPrincipal* aPrincipal,
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AutomaticStorageAccessPermissionCanBeGranted(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPrincipal);
// Sentinel = 'aPrincipal'
((&(writer__)))->WriteSentinel(364381188);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AutomaticStorageAccessPermissionCanBeGranted", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_AutomaticStorageAccessPermissionCanBeGranted__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendAutomaticStorageAccessPermissionCanBeGranted(nsIPrincipal* aPrincipal) -> RefPtr<AutomaticStorageAccessPermissionCanBeGrantedPromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendAutomaticStorageAccessPermissionCanBeGranted(std::move(aPrincipal), [promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendStorageAccessPermissionGrantedForOrigin(
const uint64_t& aTopLevelWindowId,
const MaybeDiscardedBrowsingContext& aParentContext,
nsIPrincipal* aTrackingPrincipal,
const nsACString& aTrackingOrigin,
const int& aAllowMode,
const mozilla::Maybe<StorageAccessPermissionGrantedReason>& aReason,
const bool& aFrameOnly,
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_StorageAccessPermissionGrantedForOrigin(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aTopLevelWindowId);
// Sentinel = 'aTopLevelWindowId'
((&(writer__)))->WriteSentinel(1006700210);
IPC::WriteParam((&(writer__)), aParentContext);
// Sentinel = 'aParentContext'
((&(writer__)))->WriteSentinel(692454833);
IPC::WriteParam((&(writer__)), aTrackingPrincipal);
// Sentinel = 'aTrackingPrincipal'
((&(writer__)))->WriteSentinel(1135609655);
IPC::WriteParam((&(writer__)), aTrackingOrigin);
// Sentinel = 'aTrackingOrigin'
((&(writer__)))->WriteSentinel(792331773);
IPC::WriteParam((&(writer__)), aAllowMode);
// Sentinel = 'aAllowMode'
((&(writer__)))->WriteSentinel(353108966);
IPC::WriteParam((&(writer__)), aReason);
// Sentinel = 'aReason'
((&(writer__)))->WriteSentinel(180093642);
IPC::WriteParam((&(writer__)), aFrameOnly);
// Sentinel = 'aFrameOnly'
((&(writer__)))->WriteSentinel(350159855);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_StorageAccessPermissionGrantedForOrigin", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_StorageAccessPermissionGrantedForOrigin__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendStorageAccessPermissionGrantedForOrigin(
const uint64_t& aTopLevelWindowId,
const MaybeDiscardedBrowsingContext& aParentContext,
nsIPrincipal* aTrackingPrincipal,
const nsACString& aTrackingOrigin,
const int& aAllowMode,
const mozilla::Maybe<StorageAccessPermissionGrantedReason>& aReason,
const bool& aFrameOnly) -> RefPtr<StorageAccessPermissionGrantedForOriginPromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendStorageAccessPermissionGrantedForOrigin(std::move(aTopLevelWindowId), std::move(aParentContext), std::move(aTrackingPrincipal), std::move(aTrackingOrigin), std::move(aAllowMode), std::move(aReason), std::move(aFrameOnly), [promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendCompleteAllowAccessFor(
const MaybeDiscardedBrowsingContext& aParentContext,
const uint64_t& aTopLevelWindowId,
nsIPrincipal* aTrackingPrincipal,
const nsACString& aTrackingOrigin,
const uint32_t& aCookieBehavior,
const StorageAccessPermissionGrantedReason& aReason,
mozilla::ipc::ResolveCallback<mozilla::Maybe<StorageAccessPromptChoices>>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CompleteAllowAccessFor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aParentContext);
// Sentinel = 'aParentContext'
((&(writer__)))->WriteSentinel(692454833);
IPC::WriteParam((&(writer__)), aTopLevelWindowId);
// Sentinel = 'aTopLevelWindowId'
((&(writer__)))->WriteSentinel(1006700210);
IPC::WriteParam((&(writer__)), aTrackingPrincipal);
// Sentinel = 'aTrackingPrincipal'
((&(writer__)))->WriteSentinel(1135609655);
IPC::WriteParam((&(writer__)), aTrackingOrigin);
// Sentinel = 'aTrackingOrigin'
((&(writer__)))->WriteSentinel(792331773);
IPC::WriteParam((&(writer__)), aCookieBehavior);
// Sentinel = 'aCookieBehavior'
((&(writer__)))->WriteSentinel(772408812);
IPC::WriteParam((&(writer__)), aReason);
// Sentinel = 'aReason'
((&(writer__)))->WriteSentinel(180093642);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CompleteAllowAccessFor", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_CompleteAllowAccessFor__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendCompleteAllowAccessFor(
const MaybeDiscardedBrowsingContext& aParentContext,
const uint64_t& aTopLevelWindowId,
nsIPrincipal* aTrackingPrincipal,
const nsACString& aTrackingOrigin,
const uint32_t& aCookieBehavior,
const StorageAccessPermissionGrantedReason& aReason) -> RefPtr<CompleteAllowAccessForPromise>
{
RefPtr<MozPromise<mozilla::Maybe<StorageAccessPromptChoices>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<mozilla::Maybe<StorageAccessPromptChoices>, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendCompleteAllowAccessFor(std::move(aParentContext), std::move(aTopLevelWindowId), std::move(aTrackingPrincipal), std::move(aTrackingOrigin), std::move(aCookieBehavior), std::move(aReason), [promise__](mozilla::Maybe<StorageAccessPromptChoices>&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendSetAllowStorageAccessRequestFlag(
nsIPrincipal* aEmbeddingPrincipal,
nsIURI* aEmbeddedOrigin,
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetAllowStorageAccessRequestFlag(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEmbeddingPrincipal);
// Sentinel = 'aEmbeddingPrincipal'
((&(writer__)))->WriteSentinel(1233389443);
IPC::WriteParam((&(writer__)), aEmbeddedOrigin);
// Sentinel = 'aEmbeddedOrigin'
((&(writer__)))->WriteSentinel(762906068);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetAllowStorageAccessRequestFlag", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_SetAllowStorageAccessRequestFlag__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendSetAllowStorageAccessRequestFlag(
nsIPrincipal* aEmbeddingPrincipal,
nsIURI* aEmbeddedOrigin) -> RefPtr<SetAllowStorageAccessRequestFlagPromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendSetAllowStorageAccessRequestFlag(std::move(aEmbeddingPrincipal), std::move(aEmbeddedOrigin), [promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendTestAllowStorageAccessRequestFlag(
nsIPrincipal* aEmbeddedPrincipal,
nsIURI* aEmbeddingOrigin,
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_TestAllowStorageAccessRequestFlag(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEmbeddedPrincipal);
// Sentinel = 'aEmbeddedPrincipal'
((&(writer__)))->WriteSentinel(1098123022);
IPC::WriteParam((&(writer__)), aEmbeddingOrigin);
// Sentinel = 'aEmbeddingOrigin'
((&(writer__)))->WriteSentinel(875169353);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_TestAllowStorageAccessRequestFlag", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_TestAllowStorageAccessRequestFlag__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendTestAllowStorageAccessRequestFlag(
nsIPrincipal* aEmbeddedPrincipal,
nsIURI* aEmbeddingOrigin) -> RefPtr<TestAllowStorageAccessRequestFlagPromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendTestAllowStorageAccessRequestFlag(std::move(aEmbeddedPrincipal), std::move(aEmbeddingOrigin), [promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendStoreUserInteractionAsPermission(nsIPrincipal* aPrincipal) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_StoreUserInteractionAsPermission(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPrincipal);
// Sentinel = 'aPrincipal'
((&(writer__)))->WriteSentinel(364381188);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_StoreUserInteractionAsPermission", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendTestCookiePermissionDecided(
const MaybeDiscardedBrowsingContext& aContext,
nsIPrincipal* aPrincipal,
mozilla::ipc::ResolveCallback<mozilla::Maybe<bool>>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_TestCookiePermissionDecided(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aPrincipal);
// Sentinel = 'aPrincipal'
((&(writer__)))->WriteSentinel(364381188);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_TestCookiePermissionDecided", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_TestCookiePermissionDecided__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendTestCookiePermissionDecided(
const MaybeDiscardedBrowsingContext& aContext,
nsIPrincipal* aPrincipal) -> RefPtr<TestCookiePermissionDecidedPromise>
{
RefPtr<MozPromise<mozilla::Maybe<bool>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<mozilla::Maybe<bool>, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendTestCookiePermissionDecided(std::move(aContext), std::move(aPrincipal), [promise__](mozilla::Maybe<bool>&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendTestStorageAccessPermission(
nsIPrincipal* aEmbeddingPrincipal,
const nsACString& aEmbeddedOrigin,
mozilla::ipc::ResolveCallback<mozilla::Maybe<bool>>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_TestStorageAccessPermission(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aEmbeddingPrincipal);
// Sentinel = 'aEmbeddingPrincipal'
((&(writer__)))->WriteSentinel(1233389443);
IPC::WriteParam((&(writer__)), aEmbeddedOrigin);
// Sentinel = 'aEmbeddedOrigin'
((&(writer__)))->WriteSentinel(762906068);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_TestStorageAccessPermission", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_TestStorageAccessPermission__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendTestStorageAccessPermission(
nsIPrincipal* aEmbeddingPrincipal,
const nsACString& aEmbeddedOrigin) -> RefPtr<TestStorageAccessPermissionPromise>
{
RefPtr<MozPromise<mozilla::Maybe<bool>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<mozilla::Maybe<bool>, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendTestStorageAccessPermission(std::move(aEmbeddingPrincipal), std::move(aEmbeddedOrigin), [promise__](mozilla::Maybe<bool>&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendNotifyMediaPlaybackChanged(
const MaybeDiscardedBrowsingContext& aContext,
const MediaPlaybackState& aState) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyMediaPlaybackChanged(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aState);
// Sentinel = 'aState'
((&(writer__)))->WriteSentinel(137036387);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaPlaybackChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyMediaAudibleChanged(
const MaybeDiscardedBrowsingContext& aContext,
const MediaAudibleState& aState) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyMediaAudibleChanged(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aState);
// Sentinel = 'aState'
((&(writer__)))->WriteSentinel(137036387);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaAudibleChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyPictureInPictureModeChanged(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aEnabled) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyPictureInPictureModeChanged(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aEnabled);
// Sentinel = 'aEnabled'
((&(writer__)))->WriteSentinel(224789261);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyPictureInPictureModeChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyMediaSessionUpdated(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aIsCreated) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyMediaSessionUpdated(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aIsCreated);
// Sentinel = 'aIsCreated'
((&(writer__)))->WriteSentinel(344261590);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaSessionUpdated", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyUpdateMediaMetadata(
const MaybeDiscardedBrowsingContext& aContext,
const mozilla::Maybe<MediaMetadataBase>& aMetadata) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyUpdateMediaMetadata(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aMetadata);
// Sentinel = 'aMetadata'
((&(writer__)))->WriteSentinel(288752515);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyUpdateMediaMetadata", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyMediaSessionPlaybackStateChanged(
const MaybeDiscardedBrowsingContext& aContext,
const MediaSessionPlaybackState& aMetadata) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyMediaSessionPlaybackStateChanged(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aMetadata);
// Sentinel = 'aMetadata'
((&(writer__)))->WriteSentinel(288752515);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaSessionPlaybackStateChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyMediaSessionSupportedActionChanged(
const MaybeDiscardedBrowsingContext& aContext,
const MediaSessionAction& aAction,
const bool& aEnabled) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyMediaSessionSupportedActionChanged(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aAction);
// Sentinel = 'aAction'
((&(writer__)))->WriteSentinel(175768256);
IPC::WriteParam((&(writer__)), aEnabled);
// Sentinel = 'aEnabled'
((&(writer__)))->WriteSentinel(224789261);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaSessionSupportedActionChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyMediaFullScreenState(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aIsInFullScreen) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyMediaFullScreenState(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aIsInFullScreen);
// Sentinel = 'aIsInFullScreen'
((&(writer__)))->WriteSentinel(754320840);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaFullScreenState", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyPositionStateChanged(
const MaybeDiscardedBrowsingContext& aContext,
const mozilla::Maybe<PositionState>& aState) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyPositionStateChanged(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aState);
// Sentinel = 'aState'
((&(writer__)))->WriteSentinel(137036387);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyPositionStateChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyGuessedPositionStateChanged(
const MaybeDiscardedBrowsingContext& aContext,
const nsID& aMediaId,
const mozilla::Maybe<PositionState>& aState) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyGuessedPositionStateChanged(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aMediaId);
// Sentinel = 'aMediaId'
((&(writer__)))->WriteSentinel(221905647);
IPC::WriteParam((&(writer__)), aState);
// Sentinel = 'aState'
((&(writer__)))->WriteSentinel(137036387);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyGuessedPositionStateChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendAddOrRemovePageAwakeRequest(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aShouldAddCount) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AddOrRemovePageAwakeRequest(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aShouldAddCount);
// Sentinel = 'aShouldAddCount'
((&(writer__)))->WriteSentinel(777848291);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddOrRemovePageAwakeRequest", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendReportServiceWorkerShutdownProgress(
const uint32_t& aShutdownStateId,
const Progress& aProgress) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ReportServiceWorkerShutdownProgress(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aShutdownStateId);
// Sentinel = 'aShutdownStateId'
((&(writer__)))->WriteSentinel(925238892);
IPC::WriteParam((&(writer__)), aProgress);
// Sentinel = 'aProgress'
((&(writer__)))->WriteSentinel(301794231);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReportServiceWorkerShutdownProgress", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendAbortOtherOrientationPendingPromises(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AbortOtherOrientationPendingPromises(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AbortOtherOrientationPendingPromises", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendHistoryReload(
const MaybeDiscardedBrowsingContext& aContext,
const uint32_t& aReloadFlags) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_HistoryReload(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aReloadFlags);
// Sentinel = 'aReloadFlags'
((&(writer__)))->WriteSentinel(499451046);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_HistoryReload", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyOnHistoryReload(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aForceReload,
mozilla::ipc::ResolveCallback<std::tuple<bool, mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>, mozilla::Maybe<bool>>>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyOnHistoryReload(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aForceReload);
// Sentinel = 'aForceReload'
((&(writer__)))->WriteSentinel(500499624);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyOnHistoryReload", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_NotifyOnHistoryReload__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendNotifyOnHistoryReload(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aForceReload) -> RefPtr<NotifyOnHistoryReloadPromise>
{
RefPtr<MozPromise<std::tuple<bool, mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>, mozilla::Maybe<bool>>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<std::tuple<bool, mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>, mozilla::Maybe<bool>>, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendNotifyOnHistoryReload(std::move(aContext), std::move(aForceReload), [promise__](std::tuple<bool, mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>, mozilla::Maybe<bool>>&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendHistoryCommit(
const MaybeDiscardedBrowsingContext& aContext,
const uint64_t& aLoadID,
const nsID& aChangeID,
const uint32_t& aLoadType,
const bool& aPersist,
const bool& aCloneEntryChildren,
const bool& aChannelExpired,
const uint32_t& aCacheKey) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_HistoryCommit(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aLoadID);
// Sentinel = 'aLoadID'
((&(writer__)))->WriteSentinel(170328687);
IPC::WriteParam((&(writer__)), aChangeID);
// Sentinel = 'aChangeID'
((&(writer__)))->WriteSentinel(275710773);
IPC::WriteParam((&(writer__)), aLoadType);
// Sentinel = 'aLoadType'
((&(writer__)))->WriteSentinel(286589828);
IPC::WriteParam((&(writer__)), aPersist);
// Sentinel = 'aPersist'
((&(writer__)))->WriteSentinel(238617420);
IPC::WriteParam((&(writer__)), aCloneEntryChildren);
// Sentinel = 'aCloneEntryChildren'
((&(writer__)))->WriteSentinel(1242171278);
IPC::WriteParam((&(writer__)), aChannelExpired);
// Sentinel = 'aChannelExpired'
((&(writer__)))->WriteSentinel(775554540);
IPC::WriteParam((&(writer__)), aCacheKey);
// Sentinel = 'aCacheKey'
((&(writer__)))->WriteSentinel(272827231);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_HistoryCommit", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendHistoryGo(
const MaybeDiscardedBrowsingContext& aContext,
const int32_t& aOffset,
const uint64_t& aHistoryEpoch,
const bool& aRequireUserInteraction,
const bool& aUserActivation,
mozilla::ipc::ResolveCallback<mozilla::Maybe<int32_t>>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_HistoryGo(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aOffset);
// Sentinel = 'aOffset'
((&(writer__)))->WriteSentinel(179634889);
IPC::WriteParam((&(writer__)), aHistoryEpoch);
// Sentinel = 'aHistoryEpoch'
((&(writer__)))->WriteSentinel(611255619);
IPC::WriteParam((&(writer__)), aRequireUserInteraction);
// Sentinel = 'aRequireUserInteraction'
((&(writer__)))->WriteSentinel(1862076766);
IPC::WriteParam((&(writer__)), aUserActivation);
// Sentinel = 'aUserActivation'
((&(writer__)))->WriteSentinel(794887699);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_HistoryGo", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_HistoryGo__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendHistoryGo(
const MaybeDiscardedBrowsingContext& aContext,
const int32_t& aOffset,
const uint64_t& aHistoryEpoch,
const bool& aRequireUserInteraction,
const bool& aUserActivation) -> RefPtr<HistoryGoPromise>
{
RefPtr<MozPromise<mozilla::Maybe<int32_t>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<mozilla::Maybe<int32_t>, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendHistoryGo(std::move(aContext), std::move(aOffset), std::move(aHistoryEpoch), std::move(aRequireUserInteraction), std::move(aUserActivation), [promise__](mozilla::Maybe<int32_t>&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendBlobURLDataRequest(
const nsACString& aBlobURL,
mozilla::NotNull<nsIPrincipal*> aTriggeringPrincipal,
nsIPrincipal* aLoadingPrincipal,
const OriginAttributes& aOriginAttributes,
const uint64_t& aInnerWindowId,
const nsACString& aPartitionKey,
mozilla::ipc::ResolveCallback<BlobURLDataRequestResult>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_BlobURLDataRequest(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aBlobURL);
// Sentinel = 'aBlobURL'
((&(writer__)))->WriteSentinel(218628820);
IPC::WriteParam((&(writer__)), aTriggeringPrincipal);
// Sentinel = 'aTriggeringPrincipal'
((&(writer__)))->WriteSentinel(1413089302);
IPC::WriteParam((&(writer__)), aLoadingPrincipal);
// Sentinel = 'aLoadingPrincipal'
((&(writer__)))->WriteSentinel(1001719490);
IPC::WriteParam((&(writer__)), aOriginAttributes);
// Sentinel = 'aOriginAttributes'
((&(writer__)))->WriteSentinel(1021839089);
IPC::WriteParam((&(writer__)), aInnerWindowId);
// Sentinel = 'aInnerWindowId'
((&(writer__)))->WriteSentinel(689767811);
IPC::WriteParam((&(writer__)), aPartitionKey);
// Sentinel = 'aPartitionKey'
((&(writer__)))->WriteSentinel(610141509);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_BlobURLDataRequest", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_BlobURLDataRequest__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendBlobURLDataRequest(
const nsACString& aBlobURL,
mozilla::NotNull<nsIPrincipal*> aTriggeringPrincipal,
nsIPrincipal* aLoadingPrincipal,
const OriginAttributes& aOriginAttributes,
const uint64_t& aInnerWindowId,
const nsACString& aPartitionKey) -> RefPtr<BlobURLDataRequestPromise>
{
RefPtr<MozPromise<BlobURLDataRequestResult, ResponseRejectReason, true>::Private> promise__ = new MozPromise<BlobURLDataRequestResult, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendBlobURLDataRequest(std::move(aBlobURL), std::move(aTriggeringPrincipal), std::move(aLoadingPrincipal), std::move(aOriginAttributes), std::move(aInnerWindowId), std::move(aPartitionKey), [promise__](BlobURLDataRequestResult&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendSetActiveSessionHistoryEntry(
const MaybeDiscardedBrowsingContext& context,
const mozilla::Maybe<nsPoint>& previousScrollPosition,
const SessionHistoryInfo& info,
const uint32_t& loadType,
const uint32_t& updatedCacheKey,
const nsID& changeID) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetActiveSessionHistoryEntry(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), context);
// Sentinel = 'context'
((&(writer__)))->WriteSentinel(199164678);
IPC::WriteParam((&(writer__)), previousScrollPosition);
// Sentinel = 'previousScrollPosition'
((&(writer__)))->WriteSentinel(1792346434);
IPC::WriteParam((&(writer__)), info);
// Sentinel = 'info'
((&(writer__)))->WriteSentinel(70058413);
IPC::WriteParam((&(writer__)), loadType);
// Sentinel = 'loadType'
((&(writer__)))->WriteSentinel(246088515);
IPC::WriteParam((&(writer__)), updatedCacheKey);
// Sentinel = 'updatedCacheKey'
((&(writer__)))->WriteSentinel(804062693);
IPC::WriteParam((&(writer__)), changeID);
// Sentinel = 'changeID'
((&(writer__)))->WriteSentinel(235209460);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetActiveSessionHistoryEntry", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendReplaceActiveSessionHistoryEntry(
const MaybeDiscardedBrowsingContext& context,
const SessionHistoryInfo& info) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ReplaceActiveSessionHistoryEntry(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), context);
// Sentinel = 'context'
((&(writer__)))->WriteSentinel(199164678);
IPC::WriteParam((&(writer__)), info);
// Sentinel = 'info'
((&(writer__)))->WriteSentinel(70058413);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReplaceActiveSessionHistoryEntry", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendRemoveDynEntriesFromActiveSessionHistoryEntry(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RemoveDynEntriesFromActiveSessionHistoryEntry(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RemoveDynEntriesFromActiveSessionHistoryEntry", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendRemoveFromSessionHistory(
const MaybeDiscardedBrowsingContext& aContext,
const nsID& changeID) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RemoveFromSessionHistory(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), changeID);
// Sentinel = 'changeID'
((&(writer__)))->WriteSentinel(235209460);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RemoveFromSessionHistory", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendCleanupPendingLoadState(const uint64_t& aLoadIdentifier) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CleanupPendingLoadState(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aLoadIdentifier);
// Sentinel = 'aLoadIdentifier'
((&(writer__)))->WriteSentinel(767362533);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CleanupPendingLoadState", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendScriptError(
const nsAString& message,
const nsACString& sourceName,
const uint32_t& lineNumber,
const uint32_t& colNumber,
const uint32_t& flags,
const nsACString& category,
const bool& isFromPrivateWindow,
const uint64_t& innerWindowId,
const bool& isFromChromeContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ScriptError(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), message);
// Sentinel = 'message'
((&(writer__)))->WriteSentinel(197198566);
IPC::WriteParam((&(writer__)), sourceName);
// Sentinel = 'sourceName'
((&(writer__)))->WriteSentinel(387580947);
IPC::WriteParam((&(writer__)), lineNumber);
// Sentinel = 'lineNumber'
((&(writer__)))->WriteSentinel(374932498);
IPC::WriteParam((&(writer__)), colNumber);
// Sentinel = 'colNumber'
((&(writer__)))->WriteSentinel(304284584);
IPC::WriteParam((&(writer__)), flags);
// Sentinel = 'flags'
((&(writer__)))->WriteSentinel(102171150);
IPC::WriteParam((&(writer__)), category);
// Sentinel = 'category'
((&(writer__)))->WriteSentinel(247333727);
IPC::WriteParam((&(writer__)), isFromPrivateWindow);
// Sentinel = 'isFromPrivateWindow'
((&(writer__)))->WriteSentinel(1288964036);
IPC::WriteParam((&(writer__)), innerWindowId);
// Sentinel = 'innerWindowId'
((&(writer__)))->WriteSentinel(627967298);
IPC::WriteParam((&(writer__)), isFromChromeContext);
// Sentinel = 'isFromChromeContext'
((&(writer__)))->WriteSentinel(1269368756);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ScriptError", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendReportFrameTimingData(
const LoadInfoArgs& loadInfo,
const nsAString& entryName,
const nsAString& initiatorType,
const UniquePtr<PerformanceTimingData>& aData) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ReportFrameTimingData(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), loadInfo);
// Sentinel = 'loadInfo'
((&(writer__)))->WriteSentinel(240386861);
IPC::WriteParam((&(writer__)), entryName);
// Sentinel = 'entryName'
((&(writer__)))->WriteSentinel(315950004);
IPC::WriteParam((&(writer__)), initiatorType);
// Sentinel = 'initiatorType'
((&(writer__)))->WriteSentinel(642647414);
IPC::WriteParam((&(writer__)), aData);
// Sentinel = 'aData'
((&(writer__)))->WriteSentinel(90571228);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReportFrameTimingData", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendCommitBrowsingContextTransaction(
const MaybeDiscardedBrowsingContext& aContext,
const BrowsingContextTransaction& aTransaction,
const uint64_t& aEpoch) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CommitBrowsingContextTransaction(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aTransaction);
// Sentinel = 'aTransaction'
((&(writer__)))->WriteSentinel(523371752);
IPC::WriteParam((&(writer__)), aEpoch);
// Sentinel = 'aEpoch'
((&(writer__)))->WriteSentinel(132121169);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CommitBrowsingContextTransaction", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendAsyncMessage(
const nsAString& aMessage,
const ClonedMessageData& aData) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AsyncMessage(MSG_ROUTING_CONTROL);
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("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AsyncMessage", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendNotifyPushSubscriptionModifiedObservers(
const nsACString& scope,
nsIPrincipal* principal) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyPushSubscriptionModifiedObservers(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), scope);
// Sentinel = 'scope'
((&(writer__)))->WriteSentinel(107086363);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushSubscriptionModifiedObservers", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendPushError(
const nsACString& scope,
nsIPrincipal* principal,
const nsAString& message,
const uint32_t& flags) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_PushError(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), scope);
// Sentinel = 'scope'
((&(writer__)))->WriteSentinel(107086363);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
IPC::WriteParam((&(writer__)), message);
// Sentinel = 'message'
((&(writer__)))->WriteSentinel(197198566);
IPC::WriteParam((&(writer__)), flags);
// Sentinel = 'flags'
((&(writer__)))->WriteSentinel(102171150);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PushError", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendCreateBrowsingContext(
const uint64_t& aGroupId,
const BrowsingContextInitializer& aInit) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateBrowsingContext(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aGroupId);
// Sentinel = 'aGroupId'
((&(writer__)))->WriteSentinel(233964316);
IPC::WriteParam((&(writer__)), aInit);
// Sentinel = 'aInit'
((&(writer__)))->WriteSentinel(94241270);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateBrowsingContext", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendDiscardBrowsingContext(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aDoDiscard,
mozilla::ipc::ResolveCallback<uint64_t>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_DiscardBrowsingContext(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aDoDiscard);
// Sentinel = 'aDoDiscard'
((&(writer__)))->WriteSentinel(339215311);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_DiscardBrowsingContext", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_DiscardBrowsingContext__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendDiscardBrowsingContext(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aDoDiscard) -> RefPtr<DiscardBrowsingContextPromise>
{
RefPtr<MozPromise<uint64_t, ResponseRejectReason, true>::Private> promise__ = new MozPromise<uint64_t, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendDiscardBrowsingContext(std::move(aContext), std::move(aDoDiscard), [promise__](uint64_t&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendAdjustWindowFocus(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aIsVisible,
const uint64_t& aActionId,
const bool& aShouldClearAncestorFocus,
const MaybeDiscardedBrowsingContext& aAncestorBrowsingContextToFocus) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AdjustWindowFocus(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aIsVisible);
// Sentinel = 'aIsVisible'
((&(writer__)))->WriteSentinel(353567724);
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
IPC::WriteParam((&(writer__)), aShouldClearAncestorFocus);
// Sentinel = 'aShouldClearAncestorFocus'
((&(writer__)))->WriteSentinel(2138442231);
IPC::WriteParam((&(writer__)), aAncestorBrowsingContextToFocus);
// Sentinel = 'aAncestorBrowsingContextToFocus'
((&(writer__)))->WriteSentinel(3344239764);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AdjustWindowFocus", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendWindowClose(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aTrustedCaller) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_WindowClose(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aTrustedCaller);
// Sentinel = 'aTrustedCaller'
((&(writer__)))->WriteSentinel(706479520);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_WindowClose", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendWindowFocus(
const MaybeDiscardedBrowsingContext& aContext,
const CallerType& aCallerType,
const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_WindowFocus(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aCallerType);
// Sentinel = 'aCallerType'
((&(writer__)))->WriteSentinel(422118487);
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_WindowFocus", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendWindowBlur(
const MaybeDiscardedBrowsingContext& aContext,
const CallerType& aCallerType) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_WindowBlur(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aCallerType);
// Sentinel = 'aCallerType'
((&(writer__)))->WriteSentinel(422118487);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_WindowBlur", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendRaiseWindow(
const MaybeDiscardedBrowsingContext& aContext,
const CallerType& aCallerType,
const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RaiseWindow(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aCallerType);
// Sentinel = 'aCallerType'
((&(writer__)))->WriteSentinel(422118487);
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RaiseWindow", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendClearFocus(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ClearFocus(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClearFocus", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSetFocusedBrowsingContext(
const MaybeDiscardedBrowsingContext& aContext,
const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetFocusedBrowsingContext(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetFocusedBrowsingContext", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSetActiveBrowsingContext(
const MaybeDiscardedBrowsingContext& aContext,
const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetActiveBrowsingContext(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetActiveBrowsingContext", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendUnsetActiveBrowsingContext(
const MaybeDiscardedBrowsingContext& aContext,
const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UnsetActiveBrowsingContext(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UnsetActiveBrowsingContext", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSetFocusedElement(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aNeedsFocus) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetFocusedElement(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aNeedsFocus);
// Sentinel = 'aNeedsFocus'
((&(writer__)))->WriteSentinel(419759185);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetFocusedElement", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendFinalizeFocusOuter(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aCanFocus,
const CallerType& aCallerType) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_FinalizeFocusOuter(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aCanFocus);
// Sentinel = 'aCanFocus'
((&(writer__)))->WriteSentinel(275055476);
IPC::WriteParam((&(writer__)), aCallerType);
// Sentinel = 'aCallerType'
((&(writer__)))->WriteSentinel(422118487);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_FinalizeFocusOuter", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendInsertNewFocusActionId(const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InsertNewFocusActionId(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InsertNewFocusActionId", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendBlurToParent(
const MaybeDiscardedBrowsingContext& aFocusedBrowsingContext,
const MaybeDiscardedBrowsingContext& aBrowsingContextToClear,
const MaybeDiscardedBrowsingContext& aAncestorBrowsingContextToFocus,
const bool& aIsLeavingDocument,
const bool& aAdjustWidget,
const bool& aBrowsingContextToClearHandled,
const bool& aAncestorBrowsingContextToFocusHandled,
const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_BlurToParent(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aFocusedBrowsingContext);
// Sentinel = 'aFocusedBrowsingContext'
((&(writer__)))->WriteSentinel(1842153819);
IPC::WriteParam((&(writer__)), aBrowsingContextToClear);
// Sentinel = 'aBrowsingContextToClear'
((&(writer__)))->WriteSentinel(1859127612);
IPC::WriteParam((&(writer__)), aAncestorBrowsingContextToFocus);
// Sentinel = 'aAncestorBrowsingContextToFocus'
((&(writer__)))->WriteSentinel(3344239764);
IPC::WriteParam((&(writer__)), aIsLeavingDocument);
// Sentinel = 'aIsLeavingDocument'
((&(writer__)))->WriteSentinel(1103169315);
IPC::WriteParam((&(writer__)), aAdjustWidget);
// Sentinel = 'aAdjustWidget'
((&(writer__)))->WriteSentinel(594609457);
IPC::WriteParam((&(writer__)), aBrowsingContextToClearHandled);
// Sentinel = 'aBrowsingContextToClearHandled'
((&(writer__)))->WriteSentinel(3118074860);
IPC::WriteParam((&(writer__)), aAncestorBrowsingContextToFocusHandled);
// Sentinel = 'aAncestorBrowsingContextToFocusHandled'
((&(writer__)))->WriteSentinel(701894468);
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_BlurToParent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendMaybeExitFullscreen(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_MaybeExitFullscreen(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_MaybeExitFullscreen", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendWindowPostMessage(
const MaybeDiscardedBrowsingContext& aContext,
const ClonedOrErrorMessageData& aMessage,
const PostMessageData& aData) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_WindowPostMessage(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aMessage);
// Sentinel = 'aMessage'
((&(writer__)))->WriteSentinel(233440039);
IPC::WriteParam((&(writer__)), aData);
// Sentinel = 'aData'
((&(writer__)))->WriteSentinel(90571228);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_WindowPostMessage", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendCommitWindowContextTransaction(
const MaybeDiscardedWindowContext& aContext,
const WindowContextTransaction& aTransaction,
const uint64_t& aEpoch) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CommitWindowContextTransaction(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aTransaction);
// Sentinel = 'aTransaction'
((&(writer__)))->WriteSentinel(523371752);
IPC::WriteParam((&(writer__)), aEpoch);
// Sentinel = 'aEpoch'
((&(writer__)))->WriteSentinel(132121169);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CommitWindowContextTransaction", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendFOGData(ByteBuf&& buf) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_FOGData(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), std::move(buf));
// Sentinel = 'buf'
((&(writer__)))->WriteSentinel(41484606);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_FOGData", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendSetContainerFeaturePolicy(
const MaybeDiscardedBrowsingContext& aContainerContext,
const MaybeFeaturePolicyInfo& aContainerFeaturePolicyInfo) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetContainerFeaturePolicy(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContainerContext);
// Sentinel = 'aContainerContext'
((&(writer__)))->WriteSentinel(1015744234);
IPC::WriteParam((&(writer__)), aContainerFeaturePolicyInfo);
// Sentinel = 'aContainerFeaturePolicyInfo'
((&(writer__)))->WriteSentinel(2516585165);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetContainerFeaturePolicy", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendGetSystemIcon(
nsIURI* aURI,
mozilla::ipc::ResolveCallback<std::tuple<nsresult, mozilla::Maybe<ByteBuf>>>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GetSystemIcon(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aURI);
// Sentinel = 'aURI'
((&(writer__)))->WriteSentinel(57934162);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetSystemIcon", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_GetSystemIcon__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendGetSystemIcon(nsIURI* aURI) -> RefPtr<GetSystemIconPromise>
{
RefPtr<MozPromise<std::tuple<nsresult, mozilla::Maybe<ByteBuf>>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<std::tuple<nsresult, mozilla::Maybe<ByteBuf>>, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendGetSystemIcon(std::move(aURI), [promise__](std::tuple<nsresult, mozilla::Maybe<ByteBuf>>&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendGetSystemGeolocationPermissionBehavior(
mozilla::ipc::ResolveCallback<SystemGeolocationPermissionBehavior>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GetSystemGeolocationPermissionBehavior(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetSystemGeolocationPermissionBehavior", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_GetSystemGeolocationPermissionBehavior__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendGetSystemGeolocationPermissionBehavior() -> RefPtr<GetSystemGeolocationPermissionBehaviorPromise>
{
RefPtr<MozPromise<SystemGeolocationPermissionBehavior, ResponseRejectReason, true>::Private> promise__ = new MozPromise<SystemGeolocationPermissionBehavior, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendGetSystemGeolocationPermissionBehavior([promise__](SystemGeolocationPermissionBehavior&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendRequestGeolocationPermissionFromUser(
const MaybeDiscardedBrowsingContext& aBrowsingContext,
mozilla::ipc::ResolveCallback<GeolocationPermissionStatus>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RequestGeolocationPermissionFromUser(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aBrowsingContext);
// Sentinel = 'aBrowsingContext'
((&(writer__)))->WriteSentinel(915015314);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RequestGeolocationPermissionFromUser", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_RequestGeolocationPermissionFromUser__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentChild::SendRequestGeolocationPermissionFromUser(const MaybeDiscardedBrowsingContext& aBrowsingContext) -> RefPtr<RequestGeolocationPermissionFromUserPromise>
{
RefPtr<MozPromise<GeolocationPermissionStatus, ResponseRejectReason, true>::Private> promise__ = new MozPromise<GeolocationPermissionStatus, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendRequestGeolocationPermissionFromUser(std::move(aBrowsingContext), [promise__](GeolocationPermissionStatus&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentChild::SendAttributionEvent(
const nsACString& aSourceHost,
const PrivateAttributionImpressionType& aType,
const uint32_t& aIndex,
const nsAString& aAd,
const nsACString& aTargetHost) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AttributionEvent(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aSourceHost);
// Sentinel = 'aSourceHost'
((&(writer__)))->WriteSentinel(439551089);
IPC::WriteParam((&(writer__)), aType);
// Sentinel = 'aType'
((&(writer__)))->WriteSentinel(99222020);
IPC::WriteParam((&(writer__)), aIndex);
// Sentinel = 'aIndex'
((&(writer__)))->WriteSentinel(132055642);
IPC::WriteParam((&(writer__)), aAd);
// Sentinel = 'aAd'
((&(writer__)))->WriteSentinel(34341127);
IPC::WriteParam((&(writer__)), aTargetHost);
// Sentinel = 'aTargetHost'
((&(writer__)))->WriteSentinel(431031399);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AttributionEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::SendAttributionConversion(
const nsACString& aTargetHost,
const nsAString& aTask,
const uint32_t& aHistogramSize,
const mozilla::Maybe<uint32_t>& aLookbackDays,
const mozilla::Maybe<PrivateAttributionImpressionType>& aImpressionType,
mozilla::Span<nsString const> aAds,
mozilla::Span<nsCString const> aImpressionSourceHosts) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AttributionConversion(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aTargetHost);
// Sentinel = 'aTargetHost'
((&(writer__)))->WriteSentinel(431031399);
IPC::WriteParam((&(writer__)), aTask);
// Sentinel = 'aTask'
((&(writer__)))->WriteSentinel(95289845);
IPC::WriteParam((&(writer__)), aHistogramSize);
// Sentinel = 'aHistogramSize'
((&(writer__)))->WriteSentinel(703399339);
IPC::WriteParam((&(writer__)), aLookbackDays);
// Sentinel = 'aLookbackDays'
((&(writer__)))->WriteSentinel(589301017);
IPC::WriteParam((&(writer__)), aImpressionType);
// Sentinel = 'aImpressionType'
((&(writer__)))->WriteSentinel(815728173);
IPC::WriteParam((&(writer__)), aAds);
// Sentinel = 'aAds'
((&(writer__)))->WriteSentinel(59113850);
IPC::WriteParam((&(writer__)), aImpressionSourceHosts);
// Sentinel = 'aImpressionSourceHosts'
((&(writer__)))->WriteSentinel(1726679309);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AttributionConversion", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentChild::DeallocManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
switch (aProtocolId) {
case PContentPermissionRequestMsgStart:
static_cast<ContentChild*>(this)->DeallocPContentPermissionRequestChild(static_cast<PContentPermissionRequestChild*>(aListener));
return;
case PCycleCollectWithLogsMsgStart:
static_cast<ContentChild*>(this)->DeallocPCycleCollectWithLogsChild(static_cast<PCycleCollectWithLogsChild*>(aListener));
return;
case PHalMsgStart:
static_cast<ContentChild*>(this)->DeallocPHalChild(static_cast<PHalChild*>(aListener));
return;
case PHeapSnapshotTempFileHelperMsgStart:
static_cast<ContentChild*>(this)->DeallocPHeapSnapshotTempFileHelperChild(static_cast<PHeapSnapshotTempFileHelperChild*>(aListener));
return;
case PMediaMsgStart:
static_cast<ContentChild*>(this)->DeallocPMediaChild(static_cast<PMediaChild*>(aListener));
return;
case PRemoteSpellcheckEngineMsgStart:
static_cast<ContentChild*>(this)->DeallocPRemoteSpellcheckEngineChild(static_cast<PRemoteSpellcheckEngineChild*>(aListener));
return;
case PWebrtcGlobalMsgStart:
static_cast<ContentChild*>(this)->DeallocPWebrtcGlobalChild(static_cast<PWebrtcGlobalChild*>(aListener));
return;
case PURLClassifierMsgStart:
static_cast<ContentChild*>(this)->DeallocPURLClassifierChild(static_cast<PURLClassifierChild*>(aListener));
return;
case PURLClassifierLocalMsgStart:
static_cast<ContentChild*>(this)->DeallocPURLClassifierLocalChild(static_cast<PURLClassifierLocalChild*>(aListener));
return;
case PScriptCacheMsgStart:
static_cast<ContentChild*>(this)->DeallocPScriptCacheChild(static_cast<PScriptCacheChild*>(aListener));
return;
case PSessionStorageObserverMsgStart:
static_cast<ContentChild*>(this)->DeallocPSessionStorageObserverChild(static_cast<PSessionStorageObserverChild*>(aListener));
return;
case PBenchmarkStorageMsgStart:
static_cast<ContentChild*>(this)->DeallocPBenchmarkStorageChild(static_cast<PBenchmarkStorageChild*>(aListener));
return;
default:
FatalError("unreached");
return;
}
}
auto PContentChild::OnMessageReceived(const Message& msg__) -> PContentChild::Result
{
int32_t route__ = msg__.routing_id();
if (MSG_ROUTING_CONTROL != route__) {
IProtocol* routed__ = Lookup(route__);
if (!routed__ || !routed__->GetLifecycleProxy()) {
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Ignored message for dead actor",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
RefPtr<mozilla::ipc::ActorLifecycleProxy> proxy__ =
routed__->GetLifecycleProxy();
return proxy__->Get()->OnMessageReceived(msg__);
}
switch (msg__.type()) {
case PContent::Reply_PExtensionsConstructor__ID:
{
return MsgProcessed;
}
case PContent::Msg_ConstructBrowser__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ConstructBrowser", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__browserEp = IPC::ReadParam<ManagedEndpoint<::mozilla::dom::PBrowserChild>>((&(reader__)));
if (!maybe__browserEp) {
FatalError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PBrowserChild>'");
return MsgValueError;
}
auto& browserEp = *maybe__browserEp;
// Sentinel = 'browserEp'
if ((!(((&(reader__)))->ReadSentinel(318833594)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PBrowserChild>'");
return MsgValueError;
}
auto maybe__windowEp = IPC::ReadParam<ManagedEndpoint<::mozilla::dom::PWindowGlobalChild>>((&(reader__)));
if (!maybe__windowEp) {
FatalError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PWindowGlobalChild>'");
return MsgValueError;
}
auto& windowEp = *maybe__windowEp;
// Sentinel = 'windowEp'
if ((!(((&(reader__)))->ReadSentinel(255984462)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PWindowGlobalChild>'");
return MsgValueError;
}
auto maybe__tabId = IPC::ReadParam<TabId>((&(reader__)));
if (!maybe__tabId) {
FatalError("Error deserializing 'TabId'");
return MsgValueError;
}
auto& tabId = *maybe__tabId;
// Sentinel = 'tabId'
if ((!(((&(reader__)))->ReadSentinel(99156453)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
return MsgValueError;
}
auto maybe__context = IPC::ReadParam<IPCTabContext>((&(reader__)));
if (!maybe__context) {
FatalError("Error deserializing 'IPCTabContext'");
return MsgValueError;
}
auto& context = *maybe__context;
// Sentinel = 'context'
if ((!(((&(reader__)))->ReadSentinel(199164678)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCTabContext'");
return MsgValueError;
}
auto maybe__windowInit = IPC::ReadParam<WindowGlobalInit>((&(reader__)));
if (!maybe__windowInit) {
FatalError("Error deserializing 'WindowGlobalInit'");
return MsgValueError;
}
auto& windowInit = *maybe__windowInit;
// Sentinel = 'windowInit'
if ((!(((&(reader__)))->ReadSentinel(388891693)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WindowGlobalInit'");
return MsgValueError;
}
auto maybe__chromeFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__chromeFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& chromeFlags = *maybe__chromeFlags;
// Sentinel = 'chromeFlags'
if ((!(((&(reader__)))->ReadSentinel(446760044)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__cpId = IPC::ReadParam<ContentParentId>((&(reader__)));
if (!maybe__cpId) {
FatalError("Error deserializing 'ContentParentId'");
return MsgValueError;
}
auto& cpId = *maybe__cpId;
// Sentinel = 'cpId'
if ((!(((&(reader__)))->ReadSentinel(64356737)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ContentParentId'");
return MsgValueError;
}
auto maybe__isForBrowser = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__isForBrowser) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& isForBrowser = *maybe__isForBrowser;
// Sentinel = 'isForBrowser'
if ((!(((&(reader__)))->ReadSentinel(523371752)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__isTopLevel = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__isTopLevel) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& isTopLevel = *maybe__isTopLevel;
// Sentinel = 'isTopLevel'
if ((!(((&(reader__)))->ReadSentinel(371196936)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvConstructBrowser(std::move(browserEp), std::move(windowEp), std::move(tabId), std::move(context), std::move(windowInit), std::move(chromeFlags), std::move(cpId), std::move(isForBrowser), std::move(isTopLevel));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Reply_PWebBrowserPersistDocumentConstructor__ID:
{
return MsgProcessed;
}
case PContent::Msg_PWebBrowserPersistDocumentConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PWebBrowserPersistDocumentConstructor", 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__aBrowser = IPC::ReadParam<PBrowserChild*>((&(reader__)));
if (!maybe__aBrowser) {
FatalError("Error deserializing 'PBrowser'");
return MsgValueError;
}
auto& aBrowser = *maybe__aBrowser;
// Sentinel = 'aBrowser'
if ((!(((&(reader__)))->ReadSentinel(237372230)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PBrowser'");
return MsgValueError;
}
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PWebBrowserPersistDocumentChild> actor = (static_cast<ContentChild*>(this))->AllocPWebBrowserPersistDocumentChild(aBrowser, aContext);
if (!actor) {
NS_WARNING("Cannot bind null PWebBrowserPersistDocumentChild actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PWebBrowserPersistDocumentChild actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvPWebBrowserPersistDocumentConstructor(actor, aBrowser, std::move(aContext));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RawMessage__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RawMessage", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aMetadata = IPC::ReadParam<JSActorMessageMeta>((&(reader__)));
if (!maybe__aMetadata) {
FatalError("Error deserializing 'JSActorMessageMeta'");
return MsgValueError;
}
auto& aMetadata = *maybe__aMetadata;
// Sentinel = 'aMetadata'
if ((!(((&(reader__)))->ReadSentinel(288752515)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'JSActorMessageMeta'");
return MsgValueError;
}
auto maybe__aData = IPC::ReadParam<mozilla::Maybe<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;
}
auto maybe__aStack = IPC::ReadParam<mozilla::Maybe<ClonedMessageData>>((&(reader__)));
if (!maybe__aStack) {
FatalError("Error deserializing 'ClonedMessageData?'");
return MsgValueError;
}
auto& aStack = *maybe__aStack;
// Sentinel = 'aStack'
if ((!(((&(reader__)))->ReadSentinel(135201368)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRawMessage(std::move(aMetadata), std::move(aData), std::move(aStack));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_InitGMPService__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitGMPService", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__service = IPC::ReadParam<Endpoint<::mozilla::gmp::PGMPServiceChild>>((&(reader__)));
if (!maybe__service) {
FatalError("Error deserializing 'Endpoint<::mozilla::gmp::PGMPServiceChild>'");
return MsgValueError;
}
auto& service = *maybe__service;
// Sentinel = 'service'
if ((!(((&(reader__)))->ReadSentinel(201458418)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::gmp::PGMPServiceChild>'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitGMPService(std::move(service));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_InitProcessHangMonitor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitProcessHangMonitor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__hangMonitor = IPC::ReadParam<Endpoint<::mozilla::PProcessHangMonitorChild>>((&(reader__)));
if (!maybe__hangMonitor) {
FatalError("Error deserializing 'Endpoint<::mozilla::PProcessHangMonitorChild>'");
return MsgValueError;
}
auto& hangMonitor = *maybe__hangMonitor;
// Sentinel = 'hangMonitor'
if ((!(((&(reader__)))->ReadSentinel(445514887)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PProcessHangMonitorChild>'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitProcessHangMonitor(std::move(hangMonitor));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_InitProfiler__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitProfiler", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEndpoint = IPC::ReadParam<Endpoint<::mozilla::PProfilerChild>>((&(reader__)));
if (!maybe__aEndpoint) {
FatalError("Error deserializing 'Endpoint<::mozilla::PProfilerChild>'");
return MsgValueError;
}
auto& aEndpoint = *maybe__aEndpoint;
// Sentinel = 'aEndpoint'
if ((!(((&(reader__)))->ReadSentinel(292225955)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PProfilerChild>'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitProfiler(std::move(aEndpoint));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_InitRendering__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitRendering", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__compositor = IPC::ReadParam<Endpoint<::mozilla::layers::PCompositorManagerChild>>((&(reader__)));
if (!maybe__compositor) {
FatalError("Error deserializing 'Endpoint<::mozilla::layers::PCompositorManagerChild>'");
return MsgValueError;
}
auto& compositor = *maybe__compositor;
// Sentinel = 'compositor'
if ((!(((&(reader__)))->ReadSentinel(393217104)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PCompositorManagerChild>'");
return MsgValueError;
}
auto maybe__imageBridge = IPC::ReadParam<Endpoint<::mozilla::layers::PImageBridgeChild>>((&(reader__)));
if (!maybe__imageBridge) {
FatalError("Error deserializing 'Endpoint<::mozilla::layers::PImageBridgeChild>'");
return MsgValueError;
}
auto& imageBridge = *maybe__imageBridge;
// Sentinel = 'imageBridge'
if ((!(((&(reader__)))->ReadSentinel(436012113)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PImageBridgeChild>'");
return MsgValueError;
}
auto maybe__vr = IPC::ReadParam<Endpoint<::mozilla::gfx::PVRManagerChild>>((&(reader__)));
if (!maybe__vr) {
FatalError("Error deserializing 'Endpoint<::mozilla::gfx::PVRManagerChild>'");
return MsgValueError;
}
auto& vr = *maybe__vr;
// Sentinel = 'vr'
if ((!(((&(reader__)))->ReadSentinel(23068905)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::gfx::PVRManagerChild>'");
return MsgValueError;
}
auto maybe__video = IPC::ReadParam<Endpoint<::mozilla::PRemoteDecoderManagerChild>>((&(reader__)));
if (!maybe__video) {
FatalError("Error deserializing 'Endpoint<::mozilla::PRemoteDecoderManagerChild>'");
return MsgValueError;
}
auto& video = *maybe__video;
// Sentinel = 'video'
if ((!(((&(reader__)))->ReadSentinel(106693144)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PRemoteDecoderManagerChild>'");
return MsgValueError;
}
auto maybe__namespaces = IPC::ReadParam<nsTArray<uint32_t>>((&(reader__)));
if (!maybe__namespaces) {
FatalError("Error deserializing 'uint32_t[]'");
return MsgValueError;
}
auto& namespaces = *maybe__namespaces;
// Sentinel = 'namespaces'
if ((!(((&(reader__)))->ReadSentinel(381027361)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitRendering(std::move(compositor), std::move(imageBridge), std::move(vr), std::move(video), std::move(namespaces));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ReinitRendering__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReinitRendering", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__compositor = IPC::ReadParam<Endpoint<::mozilla::layers::PCompositorManagerChild>>((&(reader__)));
if (!maybe__compositor) {
FatalError("Error deserializing 'Endpoint<::mozilla::layers::PCompositorManagerChild>'");
return MsgValueError;
}
auto& compositor = *maybe__compositor;
// Sentinel = 'compositor'
if ((!(((&(reader__)))->ReadSentinel(393217104)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PCompositorManagerChild>'");
return MsgValueError;
}
auto maybe__bridge = IPC::ReadParam<Endpoint<::mozilla::layers::PImageBridgeChild>>((&(reader__)));
if (!maybe__bridge) {
FatalError("Error deserializing 'Endpoint<::mozilla::layers::PImageBridgeChild>'");
return MsgValueError;
}
auto& bridge = *maybe__bridge;
// Sentinel = 'bridge'
if ((!(((&(reader__)))->ReadSentinel(143589998)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PImageBridgeChild>'");
return MsgValueError;
}
auto maybe__vr = IPC::ReadParam<Endpoint<::mozilla::gfx::PVRManagerChild>>((&(reader__)));
if (!maybe__vr) {
FatalError("Error deserializing 'Endpoint<::mozilla::gfx::PVRManagerChild>'");
return MsgValueError;
}
auto& vr = *maybe__vr;
// Sentinel = 'vr'
if ((!(((&(reader__)))->ReadSentinel(23068905)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::gfx::PVRManagerChild>'");
return MsgValueError;
}
auto maybe__video = IPC::ReadParam<Endpoint<::mozilla::PRemoteDecoderManagerChild>>((&(reader__)));
if (!maybe__video) {
FatalError("Error deserializing 'Endpoint<::mozilla::PRemoteDecoderManagerChild>'");
return MsgValueError;
}
auto& video = *maybe__video;
// Sentinel = 'video'
if ((!(((&(reader__)))->ReadSentinel(106693144)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PRemoteDecoderManagerChild>'");
return MsgValueError;
}
auto maybe__namespaces = IPC::ReadParam<nsTArray<uint32_t>>((&(reader__)));
if (!maybe__namespaces) {
FatalError("Error deserializing 'uint32_t[]'");
return MsgValueError;
}
auto& namespaces = *maybe__namespaces;
// Sentinel = 'namespaces'
if ((!(((&(reader__)))->ReadSentinel(381027361)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvReinitRendering(std::move(compositor), std::move(bridge), std::move(vr), std::move(video), std::move(namespaces));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NetworkLinkTypeChange__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NetworkLinkTypeChange", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__type = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__type) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& type = *maybe__type;
// Sentinel = 'type'
if ((!(((&(reader__)))->ReadSentinel(75760067)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvNetworkLinkTypeChange(std::move(type));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SocketProcessCrashed__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SocketProcessCrashed", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSocketProcessCrashed();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ReinitRenderingForDeviceReset__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReinitRenderingForDeviceReset", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvReinitRenderingForDeviceReset();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetProcessSandbox__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetProcessSandbox", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aBroker = IPC::ReadParam<mozilla::Maybe<FileDescriptor>>((&(reader__)));
if (!maybe__aBroker) {
FatalError("Error deserializing 'FileDescriptor?'");
return MsgValueError;
}
auto& aBroker = *maybe__aBroker;
// Sentinel = 'aBroker'
if ((!(((&(reader__)))->ReadSentinel(179110599)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetProcessSandbox(std::move(aBroker));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RequestMemoryReport__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RequestMemoryReport", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__generation = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__generation) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& generation = *maybe__generation;
// Sentinel = 'generation'
if ((!(((&(reader__)))->ReadSentinel(381158445)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__anonymize = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__anonymize) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& anonymize = *maybe__anonymize;
// Sentinel = 'anonymize'
if ((!(((&(reader__)))->ReadSentinel(321127387)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__minimizeMemoryUsage = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__minimizeMemoryUsage) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& minimizeMemoryUsage = *maybe__minimizeMemoryUsage;
// Sentinel = 'minimizeMemoryUsage'
if ((!(((&(reader__)))->ReadSentinel(1321600977)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__DMDFile = IPC::ReadParam<mozilla::Maybe<FileDescriptor>>((&(reader__)));
if (!maybe__DMDFile) {
FatalError("Error deserializing 'FileDescriptor?'");
return MsgValueError;
}
auto& DMDFile = *maybe__DMDFile;
// Sentinel = 'DMDFile'
if ((!(((&(reader__)))->ReadSentinel(143983190)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor?'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_RequestMemoryReport(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestMemoryReportResolver resolver = [resolver__ = std::move(resolver__)](const uint32_t& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'aGeneration'
((&(writer__)))->WriteSentinel(430179438);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRequestMemoryReport(std::move(generation), std::move(anonymize), std::move(minimizeMemoryUsage), std::move(DMDFile), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_BidiKeyboardNotify__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_BidiKeyboardNotify", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__isLangRTL = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__isLangRTL) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& isLangRTL = *maybe__isLangRTL;
// Sentinel = 'isLangRTL'
if ((!(((&(reader__)))->ReadSentinel(290980689)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__haveBidiKeyboards = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__haveBidiKeyboards) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& haveBidiKeyboards = *maybe__haveBidiKeyboards;
// Sentinel = 'haveBidiKeyboards'
if ((!(((&(reader__)))->ReadSentinel(1003161281)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvBidiKeyboardNotify(std::move(isLangRTL), std::move(haveBidiKeyboards));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PCycleCollectWithLogsConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PCycleCollectWithLogsConstructor", 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__dumpAllTraces = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__dumpAllTraces) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& dumpAllTraces = *maybe__dumpAllTraces;
// Sentinel = 'dumpAllTraces'
if ((!(((&(reader__)))->ReadSentinel(610600242)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__gcLog = IPC::ReadParam<FileDescriptor>((&(reader__)));
if (!maybe__gcLog) {
FatalError("Error deserializing 'FileDescriptor'");
return MsgValueError;
}
auto& gcLog = *maybe__gcLog;
// Sentinel = 'gcLog'
if ((!(((&(reader__)))->ReadSentinel(96272877)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor'");
return MsgValueError;
}
auto maybe__ccLog = IPC::ReadParam<FileDescriptor>((&(reader__)));
if (!maybe__ccLog) {
FatalError("Error deserializing 'FileDescriptor'");
return MsgValueError;
}
auto& ccLog = *maybe__ccLog;
// Sentinel = 'ccLog'
if ((!(((&(reader__)))->ReadSentinel(94962153)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor'");
return MsgValueError;
}
reader__.EndRead();
PCycleCollectWithLogsChild* actor = (static_cast<ContentChild*>(this))->AllocPCycleCollectWithLogsChild(dumpAllTraces, gcLog, ccLog);
if (!actor) {
NS_WARNING("Cannot bind null PCycleCollectWithLogsChild actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PCycleCollectWithLogsChild actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvPCycleCollectWithLogsConstructor(std::move(actor), std::move(dumpAllTraces), std::move(gcLog), std::move(ccLog));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PTestShellConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PTestShellConstructor", 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<PTestShellChild> actor = (static_cast<ContentChild*>(this))->AllocPTestShellChild();
if (!actor) {
NS_WARNING("Cannot bind null PTestShellChild actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PTestShellChild actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvPTestShellConstructor(actor);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PScriptCacheConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PScriptCacheConstructor", 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__cacheFile = IPC::ReadParam<FileDescOrError>((&(reader__)));
if (!maybe__cacheFile) {
FatalError("Error deserializing 'FileDescOrError'");
return MsgValueError;
}
auto& cacheFile = *maybe__cacheFile;
// Sentinel = 'cacheFile'
if ((!(((&(reader__)))->ReadSentinel(289014645)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FileDescOrError'");
return MsgValueError;
}
auto maybe__wantCacheData = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__wantCacheData) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& wantCacheData = *maybe__wantCacheData;
// Sentinel = 'wantCacheData'
if ((!(((&(reader__)))->ReadSentinel(602080521)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
PScriptCacheChild* actor = (static_cast<ContentChild*>(this))->AllocPScriptCacheChild(cacheFile, wantCacheData);
if (!actor) {
NS_WARNING("Cannot bind null PScriptCacheChild actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PScriptCacheChild actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvPScriptCacheConstructor(std::move(actor), std::move(cacheFile), std::move(wantCacheData));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RegisterChrome__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RegisterChrome", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__packages = IPC::ReadParam<nsTArray<ChromePackage>>((&(reader__)));
if (!maybe__packages) {
FatalError("Error deserializing 'ChromePackage[]'");
return MsgValueError;
}
auto& packages = *maybe__packages;
// Sentinel = 'packages'
if ((!(((&(reader__)))->ReadSentinel(244187968)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ChromePackage[]'");
return MsgValueError;
}
auto maybe__substitutions = IPC::ReadParam<nsTArray<SubstitutionMapping>>((&(reader__)));
if (!maybe__substitutions) {
FatalError("Error deserializing 'SubstitutionMapping[]'");
return MsgValueError;
}
auto& substitutions = *maybe__substitutions;
// Sentinel = 'substitutions'
if ((!(((&(reader__)))->ReadSentinel(668861873)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SubstitutionMapping[]'");
return MsgValueError;
}
auto maybe__overrides = IPC::ReadParam<nsTArray<OverrideMapping>>((&(reader__)));
if (!maybe__overrides) {
FatalError("Error deserializing 'OverrideMapping[]'");
return MsgValueError;
}
auto& overrides = *maybe__overrides;
// Sentinel = 'overrides'
if ((!(((&(reader__)))->ReadSentinel(324404180)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'OverrideMapping[]'");
return MsgValueError;
}
auto maybe__locale = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__locale) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& locale = *maybe__locale;
// Sentinel = 'locale'
if ((!(((&(reader__)))->ReadSentinel(145031793)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__reset = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__reset) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& reset = *maybe__reset;
// Sentinel = 'reset'
if ((!(((&(reader__)))->ReadSentinel(107610660)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRegisterChrome(std::move(packages), std::move(substitutions), std::move(overrides), std::move(locale), std::move(reset));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RegisterChromeItem__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RegisterChromeItem", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__item = IPC::ReadParam<ChromeRegistryItem>((&(reader__)));
if (!maybe__item) {
FatalError("Error deserializing 'ChromeRegistryItem'");
return MsgValueError;
}
auto& item = *maybe__item;
// Sentinel = 'item'
if ((!(((&(reader__)))->ReadSentinel(70975920)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ChromeRegistryItem'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRegisterChromeItem(std::move(item));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ClearImageCacheFromPrincipal__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClearImageCacheFromPrincipal", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aPrincipal = *maybe__aPrincipal;
// Sentinel = 'aPrincipal'
if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvClearImageCacheFromPrincipal(aPrincipal);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ClearImageCacheFromBaseDomain__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClearImageCacheFromBaseDomain", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aBaseDomain = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aBaseDomain) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aBaseDomain = *maybe__aBaseDomain;
// Sentinel = 'aBaseDomain'
if ((!(((&(reader__)))->ReadSentinel(409470005)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvClearImageCacheFromBaseDomain(std::move(aBaseDomain));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ClearImageCache__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClearImageCache", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__privateLoader = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__privateLoader) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& privateLoader = *maybe__privateLoader;
// Sentinel = 'privateLoader'
if ((!(((&(reader__)))->ReadSentinel(635372883)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__chrome = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__chrome) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& chrome = *maybe__chrome;
// Sentinel = 'chrome'
if ((!(((&(reader__)))->ReadSentinel(146014847)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvClearImageCache(std::move(privateLoader), std::move(chrome));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ClearStyleSheetCache__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClearStyleSheetCache", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aForPrincipal = IPC::ReadParam<mozilla::Maybe<RefPtr<nsIPrincipal>>>((&(reader__)));
if (!maybe__aForPrincipal) {
FatalError("Error deserializing 'nsIPrincipal?'");
return MsgValueError;
}
auto& aForPrincipal = *maybe__aForPrincipal;
// Sentinel = 'aForPrincipal'
if ((!(((&(reader__)))->ReadSentinel(593429803)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal?'");
return MsgValueError;
}
auto maybe__aBaseDomain = IPC::ReadParam<mozilla::Maybe<nsCString>>((&(reader__)));
if (!maybe__aBaseDomain) {
FatalError("Error deserializing 'nsCString?'");
return MsgValueError;
}
auto& aBaseDomain = *maybe__aBaseDomain;
// Sentinel = 'aBaseDomain'
if ((!(((&(reader__)))->ReadSentinel(409470005)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvClearStyleSheetCache(std::move(aForPrincipal), std::move(aBaseDomain));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ClearScriptCache__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClearScriptCache", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aForPrincipal = IPC::ReadParam<mozilla::Maybe<RefPtr<nsIPrincipal>>>((&(reader__)));
if (!maybe__aForPrincipal) {
FatalError("Error deserializing 'nsIPrincipal?'");
return MsgValueError;
}
auto& aForPrincipal = *maybe__aForPrincipal;
// Sentinel = 'aForPrincipal'
if ((!(((&(reader__)))->ReadSentinel(593429803)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal?'");
return MsgValueError;
}
auto maybe__aBaseDomain = IPC::ReadParam<mozilla::Maybe<nsCString>>((&(reader__)));
if (!maybe__aBaseDomain) {
FatalError("Error deserializing 'nsCString?'");
return MsgValueError;
}
auto& aBaseDomain = *maybe__aBaseDomain;
// Sentinel = 'aBaseDomain'
if ((!(((&(reader__)))->ReadSentinel(409470005)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvClearScriptCache(std::move(aForPrincipal), std::move(aBaseDomain));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetOffline__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetOffline", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__offline = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__offline) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& offline = *maybe__offline;
// Sentinel = 'offline'
if ((!(((&(reader__)))->ReadSentinel(194904804)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetOffline(std::move(offline));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetConnectivity__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetConnectivity", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__connectivity = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__connectivity) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& connectivity = *maybe__connectivity;
// Sentinel = 'connectivity'
if ((!(((&(reader__)))->ReadSentinel(548734240)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetConnectivity(std::move(connectivity));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetCaptivePortalState__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetCaptivePortalState", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aState = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aState) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aState = *maybe__aState;
// Sentinel = 'aState'
if ((!(((&(reader__)))->ReadSentinel(137036387)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetCaptivePortalState(std::move(aState));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetTRRMode__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetTRRMode", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aMode = IPC::ReadParam<ResolverMode>((&(reader__)));
if (!maybe__aMode) {
FatalError("Error deserializing 'ResolverMode'");
return MsgValueError;
}
auto& aMode = *maybe__aMode;
// Sentinel = 'aMode'
if ((!(((&(reader__)))->ReadSentinel(93848039)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ResolverMode'");
return MsgValueError;
}
auto maybe__aModeFromPref = IPC::ReadParam<ResolverMode>((&(reader__)));
if (!maybe__aModeFromPref) {
FatalError("Error deserializing 'ResolverMode'");
return MsgValueError;
}
auto& aModeFromPref = *maybe__aModeFromPref;
// Sentinel = 'aModeFromPref'
if ((!(((&(reader__)))->ReadSentinel(580846856)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ResolverMode'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetTRRMode(std::move(aMode), std::move(aModeFromPref));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyVisited__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyVisited", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__uri = IPC::ReadParam<nsTArray<VisitedQueryResult>>((&(reader__)));
if (!maybe__uri) {
FatalError("Error deserializing 'VisitedQueryResult[]'");
return MsgValueError;
}
auto& uri = *maybe__uri;
// Sentinel = 'uri'
if ((!(((&(reader__)))->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'VisitedQueryResult[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvNotifyVisited(std::move(uri));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ThemeChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ThemeChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__lookAndFeelData = IPC::ReadParam<FullLookAndFeel>((&(reader__)));
if (!maybe__lookAndFeelData) {
FatalError("Error deserializing 'FullLookAndFeel'");
return MsgValueError;
}
auto& lookAndFeelData = *maybe__lookAndFeelData;
// Sentinel = 'lookAndFeelData'
if ((!(((&(reader__)))->ReadSentinel(782239167)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FullLookAndFeel'");
return MsgValueError;
}
auto maybe__aKind = IPC::ReadParam<ThemeChangeKind>((&(reader__)));
if (!maybe__aKind) {
FatalError("Error deserializing 'ThemeChangeKind'");
return MsgValueError;
}
auto& aKind = *maybe__aKind;
// Sentinel = 'aKind'
if ((!(((&(reader__)))->ReadSentinel(93389288)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ThemeChangeKind'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvThemeChanged(std::move(lookAndFeelData), std::move(aKind));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PreferenceUpdate__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PreferenceUpdate", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__pref = IPC::ReadParam<Pref>((&(reader__)));
if (!maybe__pref) {
FatalError("Error deserializing 'Pref'");
return MsgValueError;
}
auto& pref = *maybe__pref;
// Sentinel = 'pref'
if ((!(((&(reader__)))->ReadSentinel(71958958)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Pref'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvPreferenceUpdate(std::move(pref));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_VarUpdate__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_VarUpdate", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__var = IPC::ReadParam<GfxVarUpdate>((&(reader__)));
if (!maybe__var) {
FatalError("Error deserializing 'GfxVarUpdate'");
return MsgValueError;
}
auto& var = *maybe__var;
// Sentinel = 'var'
if ((!(((&(reader__)))->ReadSentinel(43581770)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'GfxVarUpdate'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvVarUpdate(std::move(var));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UpdatePerfStatsCollectionMask__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdatePerfStatsCollectionMask", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aMask = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aMask) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aMask = *maybe__aMask;
// Sentinel = 'aMask'
if ((!(((&(reader__)))->ReadSentinel(93454830)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdatePerfStatsCollectionMask(std::move(aMask));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CollectPerfStatsJSON__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CollectPerfStatsJSON", OTHER);
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_CollectPerfStatsJSON(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
CollectPerfStatsJSONResolver 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 = 'aStats'
((&(writer__)))->WriteSentinel(137953905);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvCollectPerfStatsJSON(std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CollectScrollingMetrics__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CollectScrollingMetrics", OTHER);
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_CollectScrollingMetrics(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
CollectScrollingMetricsResolver resolver = [resolver__ = std::move(resolver__)](std::tuple<const uint32_t&, const uint32_t&> aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), std::get<0>(aParam));
// Sentinel = 'pixelsScrolled'
((&(writer__)))->WriteSentinel(738395598);
IPC::WriteParam((&(writer__)), std::get<1>(aParam));
// Sentinel = 'scrollDurationMS'
((&(writer__)))->WriteSentinel(945030774);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvCollectScrollingMetrics(std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyAlertsObserver__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyAlertsObserver", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__topic = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__topic) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& topic = *maybe__topic;
// Sentinel = 'topic'
if ((!(((&(reader__)))->ReadSentinel(109707808)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__data = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__data) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& data = *maybe__data;
// Sentinel = 'data'
if ((!(((&(reader__)))->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvNotifyAlertsObserver(std::move(topic), std::move(data));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_GeolocationUpdate__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GeolocationUpdate", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPosition = IPC::ReadParam<RefPtr<nsIDOMGeoPosition>>((&(reader__)));
if (!maybe__aPosition) {
FatalError("Error deserializing 'nsIDOMGeoPosition'");
return MsgValueError;
}
auto& aPosition = *maybe__aPosition;
// Sentinel = 'aPosition'
if ((!(((&(reader__)))->ReadSentinel(303104951)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIDOMGeoPosition'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGeolocationUpdate(aPosition);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_GeolocationError__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GeolocationError", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__errorCode = IPC::ReadParam<uint16_t>((&(reader__)));
if (!maybe__errorCode) {
FatalError("Error deserializing 'uint16_t'");
return MsgValueError;
}
auto& errorCode = *maybe__errorCode;
// Sentinel = 'errorCode'
if ((!(((&(reader__)))->ReadSentinel(312345510)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint16_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGeolocationError(std::move(errorCode));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UpdateDictionaryList__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateDictionaryList", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__dictionaries = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
if (!maybe__dictionaries) {
FatalError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto& dictionaries = *maybe__dictionaries;
// Sentinel = 'dictionaries'
if ((!(((&(reader__)))->ReadSentinel(540738815)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateDictionaryList(std::move(dictionaries));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UpdateFontList__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateFontList", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__fontList = IPC::ReadParam<SystemFontList>((&(reader__)));
if (!maybe__fontList) {
FatalError("Error deserializing 'SystemFontList'");
return MsgValueError;
}
auto& fontList = *maybe__fontList;
// Sentinel = 'fontList'
if ((!(((&(reader__)))->ReadSentinel(249430868)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SystemFontList'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateFontList(std::move(fontList));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RebuildFontList__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RebuildFontList", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aFullRebuild = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aFullRebuild) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aFullRebuild = *maybe__aFullRebuild;
// Sentinel = 'aFullRebuild'
if ((!(((&(reader__)))->ReadSentinel(506004668)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRebuildFontList(std::move(aFullRebuild));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_FontListChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FontListChanged", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvFontListChanged();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ForceGlobalReflow__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ForceGlobalReflow", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aNeedsReframe = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aNeedsReframe) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aNeedsReframe = *maybe__aNeedsReframe;
// Sentinel = 'aNeedsReframe'
if ((!(((&(reader__)))->ReadSentinel(583730451)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvForceGlobalReflow(std::move(aNeedsReframe));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_FontListShmBlockAdded__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FontListShmBlockAdded", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aGeneration = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aGeneration) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aGeneration = *maybe__aGeneration;
// Sentinel = 'aGeneration'
if ((!(((&(reader__)))->ReadSentinel(430179438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aIndex = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aIndex) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aIndex = *maybe__aIndex;
// Sentinel = 'aIndex'
if ((!(((&(reader__)))->ReadSentinel(132055642)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aHandle = IPC::ReadParam<SharedMemoryHandle>((&(reader__)));
if (!maybe__aHandle) {
FatalError("Error deserializing 'SharedMemoryHandle'");
return MsgValueError;
}
auto& aHandle = *maybe__aHandle;
// Sentinel = 'aHandle'
if ((!(((&(reader__)))->ReadSentinel(174326446)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SharedMemoryHandle'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvFontListShmBlockAdded(std::move(aGeneration), std::move(aIndex), std::move(aHandle));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UpdateAppLocales__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateAppLocales", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__appLocales = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
if (!maybe__appLocales) {
FatalError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto& appLocales = *maybe__appLocales;
// Sentinel = 'appLocales'
if ((!(((&(reader__)))->ReadSentinel(367395845)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateAppLocales(std::move(appLocales));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UpdateRequestedLocales__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateRequestedLocales", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__requestedLocales = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
if (!maybe__requestedLocales) {
FatalError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto& requestedLocales = *maybe__requestedLocales;
// Sentinel = 'requestedLocales'
if ((!(((&(reader__)))->ReadSentinel(951977622)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateRequestedLocales(std::move(requestedLocales));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SystemTimezoneChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SystemTimezoneChanged", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSystemTimezoneChanged();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UpdateL10nFileSources__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateL10nFileSources", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__sources = IPC::ReadParam<nsTArray<L10nFileSourceDescriptor>>((&(reader__)));
if (!maybe__sources) {
FatalError("Error deserializing 'L10nFileSourceDescriptor[]'");
return MsgValueError;
}
auto& sources = *maybe__sources;
// Sentinel = 'sources'
if ((!(((&(reader__)))->ReadSentinel(205325061)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'L10nFileSourceDescriptor[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateL10nFileSources(std::move(sources));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RegisterStringBundles__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RegisterStringBundles", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__stringBundles = IPC::ReadParam<nsTArray<StringBundleDescriptor>>((&(reader__)));
if (!maybe__stringBundles) {
FatalError("Error deserializing 'StringBundleDescriptor[]'");
return MsgValueError;
}
auto& stringBundles = *maybe__stringBundles;
// Sentinel = 'stringBundles'
if ((!(((&(reader__)))->ReadSentinel(640484709)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'StringBundleDescriptor[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRegisterStringBundles(std::move(stringBundles));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UpdateSharedData__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateSharedData", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__mapFile = IPC::ReadParam<FileDescriptor>((&(reader__)));
if (!maybe__mapFile) {
FatalError("Error deserializing 'FileDescriptor'");
return MsgValueError;
}
auto& mapFile = *maybe__mapFile;
// Sentinel = 'mapFile'
if ((!(((&(reader__)))->ReadSentinel(185074367)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor'");
return MsgValueError;
}
auto maybe__aSize = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aSize) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aSize = *maybe__aSize;
// Sentinel = 'aSize'
if ((!(((&(reader__)))->ReadSentinel(97124861)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__blobs = IPC::ReadParam<nsTArray<IPCBlob>>((&(reader__)));
if (!maybe__blobs) {
FatalError("Error deserializing 'IPCBlob[]'");
return MsgValueError;
}
auto& blobs = *maybe__blobs;
// Sentinel = 'blobs'
if ((!(((&(reader__)))->ReadSentinel(102957587)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCBlob[]'");
return MsgValueError;
}
auto maybe__changedKeys = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
if (!maybe__changedKeys) {
FatalError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto& changedKeys = *maybe__changedKeys;
// Sentinel = 'changedKeys'
if ((!(((&(reader__)))->ReadSentinel(437781607)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateSharedData(std::move(mapFile), std::move(aSize), std::move(blobs), std::move(changedKeys));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AddPermission__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddPermission", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__permission = IPC::ReadParam<Permission>((&(reader__)));
if (!maybe__permission) {
FatalError("Error deserializing 'Permission'");
return MsgValueError;
}
auto& permission = *maybe__permission;
// Sentinel = 'permission'
if ((!(((&(reader__)))->ReadSentinel(394921034)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Permission'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvAddPermission(std::move(permission));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RemoveAllPermissions__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RemoveAllPermissions", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRemoveAllPermissions();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_FlushMemory__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FlushMemory", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__reason = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__reason) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& reason = *maybe__reason;
// Sentinel = 'reason'
if ((!(((&(reader__)))->ReadSentinel(148112009)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvFlushMemory(std::move(reason));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ApplicationBackground__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ApplicationBackground", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvApplicationBackground();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ApplicationForeground__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ApplicationForeground", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvApplicationForeground();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_GarbageCollect__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GarbageCollect", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGarbageCollect();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CycleCollect__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CycleCollect", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvCycleCollect();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UnlinkGhosts__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UnlinkGhosts", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUnlinkGhosts();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ActivateA11y__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ActivateA11y", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aDomains = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aDomains) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aDomains = *maybe__aDomains;
// Sentinel = 'aDomains'
if ((!(((&(reader__)))->ReadSentinel(229966637)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvActivateA11y(std::move(aDomains));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ShutdownA11y__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ShutdownA11y", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvShutdownA11y();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetCacheDomains__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetCacheDomains", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aCacheDomains = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aCacheDomains) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aCacheDomains = *maybe__aCacheDomains;
// Sentinel = 'aCacheDomains'
if ((!(((&(reader__)))->ReadSentinel(563873025)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetCacheDomains(std::move(aCacheDomains));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AppInfo__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AppInfo", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__version = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__version) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& version = *maybe__version;
// Sentinel = 'version'
if ((!(((&(reader__)))->ReadSentinel(204210951)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__buildID = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__buildID) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& buildID = *maybe__buildID;
// Sentinel = 'buildID'
if ((!(((&(reader__)))->ReadSentinel(187826846)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__name = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__name) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& name = *maybe__name;
// Sentinel = 'name'
if ((!(((&(reader__)))->ReadSentinel(69075362)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__UAName = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__UAName) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& UAName = *maybe__UAName;
// Sentinel = 'UAName'
if ((!(((&(reader__)))->ReadSentinel(115540504)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__ID = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__ID) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& ID = *maybe__ID;
// Sentinel = 'ID'
if ((!(((&(reader__)))->ReadSentinel(14155918)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__vendor = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__vendor) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& vendor = *maybe__vendor;
// Sentinel = 'vendor'
if ((!(((&(reader__)))->ReadSentinel(150405775)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__sourceURL = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__sourceURL) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& sourceURL = *maybe__sourceURL;
// Sentinel = 'sourceURL'
if ((!(((&(reader__)))->ReadSentinel(316474245)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__updateURL = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__updateURL) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& updateURL = *maybe__updateURL;
// Sentinel = 'updateURL'
if ((!(((&(reader__)))->ReadSentinel(309265271)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvAppInfo(std::move(version), std::move(buildID), std::move(name), std::move(UAName), std::move(ID), std::move(vendor), std::move(sourceURL), std::move(updateURL));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RemoteType__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RemoteType", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aRemoteType = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aRemoteType) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aRemoteType = *maybe__aRemoteType;
// Sentinel = 'aRemoteType'
if ((!(((&(reader__)))->ReadSentinel(437847152)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aProfile = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aProfile) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aProfile = *maybe__aProfile;
// Sentinel = 'aProfile'
if ((!(((&(reader__)))->ReadSentinel(237437747)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRemoteType(std::move(aRemoteType), std::move(aProfile));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_InitRemoteWorkerService__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitRemoteWorkerService", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEndpoint = IPC::ReadParam<Endpoint<::mozilla::dom::PRemoteWorkerServiceChild>>((&(reader__)));
if (!maybe__aEndpoint) {
FatalError("Error deserializing 'Endpoint<::mozilla::dom::PRemoteWorkerServiceChild>'");
return MsgValueError;
}
auto& aEndpoint = *maybe__aEndpoint;
// Sentinel = 'aEndpoint'
if ((!(((&(reader__)))->ReadSentinel(292225955)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::dom::PRemoteWorkerServiceChild>'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitRemoteWorkerService(std::move(aEndpoint));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_InitBlobURLs__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitBlobURLs", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__registrations = IPC::ReadParam<nsTArray<BlobURLRegistrationData>>((&(reader__)));
if (!maybe__registrations) {
FatalError("Error deserializing 'BlobURLRegistrationData[]'");
return MsgValueError;
}
auto& registrations = *maybe__registrations;
// Sentinel = 'registrations'
if ((!(((&(reader__)))->ReadSentinel(648873359)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'BlobURLRegistrationData[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitBlobURLs(std::move(registrations));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_InitJSActorInfos__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitJSActorInfos", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContentInfos = IPC::ReadParam<nsTArray<JSProcessActorInfo>>((&(reader__)));
if (!maybe__aContentInfos) {
FatalError("Error deserializing 'JSProcessActorInfo[]'");
return MsgValueError;
}
auto& aContentInfos = *maybe__aContentInfos;
// Sentinel = 'aContentInfos'
if ((!(((&(reader__)))->ReadSentinel(600638780)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'JSProcessActorInfo[]'");
return MsgValueError;
}
auto maybe__aWindowInfos = IPC::ReadParam<nsTArray<JSWindowActorInfo>>((&(reader__)));
if (!maybe__aWindowInfos) {
FatalError("Error deserializing 'JSWindowActorInfo[]'");
return MsgValueError;
}
auto& aWindowInfos = *maybe__aWindowInfos;
// Sentinel = 'aWindowInfos'
if ((!(((&(reader__)))->ReadSentinel(518522073)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'JSWindowActorInfo[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitJSActorInfos(std::move(aContentInfos), std::move(aWindowInfos));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UnregisterJSWindowActor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UnregisterJSWindowActor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__name = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__name) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& name = *maybe__name;
// Sentinel = 'name'
if ((!(((&(reader__)))->ReadSentinel(69075362)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUnregisterJSWindowActor(std::move(name));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UnregisterJSProcessActor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UnregisterJSProcessActor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__name = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__name) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& name = *maybe__name;
// Sentinel = 'name'
if ((!(((&(reader__)))->ReadSentinel(69075362)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUnregisterJSProcessActor(std::move(name));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetXPCOMProcessAttributes__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetXPCOMProcessAttributes", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__xpcomInit = IPC::ReadParam<XPCOMInitData>((&(reader__)));
if (!maybe__xpcomInit) {
FatalError("Error deserializing 'XPCOMInitData'");
return MsgValueError;
}
auto& xpcomInit = *maybe__xpcomInit;
// Sentinel = 'xpcomInit'
if ((!(((&(reader__)))->ReadSentinel(316998588)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'XPCOMInitData'");
return MsgValueError;
}
auto maybe__initialData = IPC::ReadParam<StructuredCloneData>((&(reader__)));
if (!maybe__initialData) {
FatalError("Error deserializing 'StructuredCloneData'");
return MsgValueError;
}
auto& initialData = *maybe__initialData;
// Sentinel = 'initialData'
if ((!(((&(reader__)))->ReadSentinel(451413093)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'StructuredCloneData'");
return MsgValueError;
}
auto maybe__lookAndFeeldata = IPC::ReadParam<FullLookAndFeel>((&(reader__)));
if (!maybe__lookAndFeeldata) {
FatalError("Error deserializing 'FullLookAndFeel'");
return MsgValueError;
}
auto& lookAndFeeldata = *maybe__lookAndFeeldata;
// Sentinel = 'lookAndFeeldata'
if ((!(((&(reader__)))->ReadSentinel(790627807)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FullLookAndFeel'");
return MsgValueError;
}
auto maybe__systemFontList = IPC::ReadParam<SystemFontList>((&(reader__)));
if (!maybe__systemFontList) {
FatalError("Error deserializing 'SystemFontList'");
return MsgValueError;
}
auto& systemFontList = *maybe__systemFontList;
// Sentinel = 'systemFontList'
if ((!(((&(reader__)))->ReadSentinel(746194393)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SystemFontList'");
return MsgValueError;
}
auto maybe__sharedUASheetHandle = IPC::ReadParam<mozilla::Maybe<SharedMemoryHandle>>((&(reader__)));
if (!maybe__sharedUASheetHandle) {
FatalError("Error deserializing 'SharedMemoryHandle?'");
return MsgValueError;
}
auto& sharedUASheetHandle = *maybe__sharedUASheetHandle;
// Sentinel = 'sharedUASheetHandle'
if ((!(((&(reader__)))->ReadSentinel(1232406355)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SharedMemoryHandle?'");
return MsgValueError;
}
auto maybe__sharedUASheetAddress = IPC::ReadParam<uintptr_t>((&(reader__)));
if (!maybe__sharedUASheetAddress) {
FatalError("Error deserializing 'uintptr_t'");
return MsgValueError;
}
auto& sharedUASheetAddress = *maybe__sharedUASheetAddress;
// Sentinel = 'sharedUASheetAddress'
if ((!(((&(reader__)))->ReadSentinel(1361643469)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uintptr_t'");
return MsgValueError;
}
auto maybe__sharedFontListBlocks = IPC::ReadParam<nsTArray<SharedMemoryHandle>>((&(reader__)));
if (!maybe__sharedFontListBlocks) {
FatalError("Error deserializing 'SharedMemoryHandle[]'");
return MsgValueError;
}
auto& sharedFontListBlocks = *maybe__sharedFontListBlocks;
// Sentinel = 'sharedFontListBlocks'
if ((!(((&(reader__)))->ReadSentinel(1412827145)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SharedMemoryHandle[]'");
return MsgValueError;
}
auto maybe__aIsStartingUp = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aIsStartingUp) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aIsStartingUp = *maybe__aIsStartingUp;
// Sentinel = 'aIsStartingUp'
if ((!(((&(reader__)))->ReadSentinel(597361967)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetXPCOMProcessAttributes(std::move(xpcomInit), std::move(initialData), std::move(lookAndFeeldata), std::move(systemFontList), std::move(sharedUASheetHandle), std::move(sharedUASheetAddress), std::move(sharedFontListBlocks), std::move(aIsStartingUp));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_LastPrivateDocShellDestroyed__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_LastPrivateDocShellDestroyed", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvLastPrivateDocShellDestroyed();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyProcessPriorityChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyProcessPriorityChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__priority = IPC::ReadParam<ProcessPriority>((&(reader__)));
if (!maybe__priority) {
FatalError("Error deserializing 'ProcessPriority'");
return MsgValueError;
}
auto& priority = *maybe__priority;
// Sentinel = 'priority'
if ((!(((&(reader__)))->ReadSentinel(262865795)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ProcessPriority'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvNotifyProcessPriorityChanged(std::move(priority));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_MinimizeMemoryUsage__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_MinimizeMemoryUsage", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvMinimizeMemoryUsage();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_LoadAndRegisterSheet__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_LoadAndRegisterSheet", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__uri = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__uri) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& uri = *maybe__uri;
// Sentinel = 'uri'
if ((!(((&(reader__)))->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__type = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__type) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& type = *maybe__type;
// Sentinel = 'type'
if ((!(((&(reader__)))->ReadSentinel(75760067)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvLoadAndRegisterSheet(uri, std::move(type));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UnregisterSheet__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UnregisterSheet", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__uri = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__uri) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& uri = *maybe__uri;
// Sentinel = 'uri'
if ((!(((&(reader__)))->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__type = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__type) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& type = *maybe__type;
// Sentinel = 'type'
if ((!(((&(reader__)))->ReadSentinel(75760067)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUnregisterSheet(uri, std::move(type));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyIdleObserver__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyIdleObserver", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__observerId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__observerId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& observerId = *maybe__observerId;
// Sentinel = 'observerId'
if ((!(((&(reader__)))->ReadSentinel(386335766)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__topic = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__topic) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& topic = *maybe__topic;
// Sentinel = 'topic'
if ((!(((&(reader__)))->ReadSentinel(109707808)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__str = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__str) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& str = *maybe__str;
// Sentinel = 'str'
if ((!(((&(reader__)))->ReadSentinel(45482330)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvNotifyIdleObserver(std::move(observerId), std::move(topic), std::move(str));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_DomainSetChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_DomainSetChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aSetType = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aSetType) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aSetType = *maybe__aSetType;
// Sentinel = 'aSetType'
if ((!(((&(reader__)))->ReadSentinel(234292016)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aChangeType = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aChangeType) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aChangeType = *maybe__aChangeType;
// Sentinel = 'aChangeType'
if ((!(((&(reader__)))->ReadSentinel(417924170)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aDomain = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__aDomain) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& aDomain = *maybe__aDomain;
// Sentinel = 'aDomain'
if ((!(((&(reader__)))->ReadSentinel(176685754)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvDomainSetChanged(std::move(aSetType), std::move(aChangeType), aDomain);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ShutdownConfirmedHP__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ShutdownConfirmedHP", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvShutdownConfirmedHP();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_Shutdown__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_Shutdown", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvShutdown();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_LoadProcessScript__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_LoadProcessScript", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__url = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__url) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& url = *maybe__url;
// Sentinel = 'url'
if ((!(((&(reader__)))->ReadSentinel(45220180)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvLoadProcessScript(std::move(url));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UpdateWindow__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateWindow", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aChildId = IPC::ReadParam<uintptr_t>((&(reader__)));
if (!maybe__aChildId) {
FatalError("Error deserializing 'uintptr_t'");
return MsgValueError;
}
auto& aChildId = *maybe__aChildId;
// Sentinel = 'aChildId'
if ((!(((&(reader__)))->ReadSentinel(221512435)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uintptr_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateWindow(std::move(aChildId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyEmptyHTTPCache__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyEmptyHTTPCache", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvNotifyEmptyHTTPCache();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_Push__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_Push", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__scope = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__scope) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& scope = *maybe__scope;
// Sentinel = 'scope'
if ((!(((&(reader__)))->ReadSentinel(107086363)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
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__messageId = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__messageId) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& messageId = *maybe__messageId;
// Sentinel = 'messageId'
if ((!(((&(reader__)))->ReadSentinel(310576019)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvPush(std::move(scope), principal, std::move(messageId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PushWithData__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PushWithData", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__scope = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__scope) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& scope = *maybe__scope;
// Sentinel = 'scope'
if ((!(((&(reader__)))->ReadSentinel(107086363)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
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__messageId = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__messageId) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& messageId = *maybe__messageId;
// Sentinel = 'messageId'
if ((!(((&(reader__)))->ReadSentinel(310576019)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__data = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__data) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& data = *maybe__data;
// Sentinel = 'data'
if ((!(((&(reader__)))->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvPushWithData(std::move(scope), principal, std::move(messageId), std::move(data));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PushSubscriptionChange__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PushSubscriptionChange", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__scope = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__scope) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& scope = *maybe__scope;
// Sentinel = 'scope'
if ((!(((&(reader__)))->ReadSentinel(107086363)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
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;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvPushSubscriptionChange(std::move(scope), principal);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_GetFilesResponse__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetFilesResponse", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aID = IPC::ReadParam<nsID>((&(reader__)));
if (!maybe__aID) {
FatalError("Error deserializing 'nsID'");
return MsgValueError;
}
auto& aID = *maybe__aID;
// Sentinel = 'aID'
if ((!(((&(reader__)))->ReadSentinel(33292527)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
return MsgValueError;
}
auto maybe__aResult = IPC::ReadParam<GetFilesResponseResult>((&(reader__)));
if (!maybe__aResult) {
FatalError("Error deserializing 'GetFilesResponseResult'");
return MsgValueError;
}
auto& aResult = *maybe__aResult;
// Sentinel = 'aResult'
if ((!(((&(reader__)))->ReadSentinel(185205473)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'GetFilesResponseResult'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGetFilesResponse(std::move(aID), std::move(aResult));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_BlobURLRegistration__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_BlobURLRegistration", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aURI = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aURI) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aURI = *maybe__aURI;
// Sentinel = 'aURI'
if ((!(((&(reader__)))->ReadSentinel(57934162)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aBlob = IPC::ReadParam<IPCBlob>((&(reader__)));
if (!maybe__aBlob) {
FatalError("Error deserializing 'IPCBlob'");
return MsgValueError;
}
auto& aBlob = *maybe__aBlob;
// Sentinel = 'aBlob'
if ((!(((&(reader__)))->ReadSentinel(91619809)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCBlob'");
return MsgValueError;
}
auto maybe__aPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aPrincipal = *maybe__aPrincipal;
// Sentinel = 'aPrincipal'
if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__aPartitionKey = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aPartitionKey) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aPartitionKey = *maybe__aPartitionKey;
// Sentinel = 'aPartitionKey'
if ((!(((&(reader__)))->ReadSentinel(610141509)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvBlobURLRegistration(std::move(aURI), std::move(aBlob), aPrincipal, std::move(aPartitionKey));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_BlobURLUnregistration__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_BlobURLUnregistration", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aURI = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aURI) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aURI = *maybe__aURI;
// Sentinel = 'aURI'
if ((!(((&(reader__)))->ReadSentinel(57934162)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvBlobURLUnregistration(std::move(aURI));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_GMPsChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GMPsChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__capabilities = IPC::ReadParam<nsTArray<GMPCapabilityData>>((&(reader__)));
if (!maybe__capabilities) {
FatalError("Error deserializing 'GMPCapabilityData[]'");
return MsgValueError;
}
auto& capabilities = *maybe__capabilities;
// Sentinel = 'capabilities'
if ((!(((&(reader__)))->ReadSentinel(527434987)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'GMPCapabilityData[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGMPsChanged(std::move(capabilities));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ProvideAnonymousTemporaryFile__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ProvideAnonymousTemporaryFile", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aID = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aID) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aID = *maybe__aID;
// Sentinel = 'aID'
if ((!(((&(reader__)))->ReadSentinel(33292527)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aFD = IPC::ReadParam<FileDescOrError>((&(reader__)));
if (!maybe__aFD) {
FatalError("Error deserializing 'FileDescOrError'");
return MsgValueError;
}
auto& aFD = *maybe__aFD;
// Sentinel = 'aFD'
if ((!(((&(reader__)))->ReadSentinel(32899308)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FileDescOrError'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvProvideAnonymousTemporaryFile(std::move(aID), std::move(aFD));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetPermissionsWithKey__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetPermissionsWithKey", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPermissionKey = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aPermissionKey) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aPermissionKey = *maybe__aPermissionKey;
// Sentinel = 'aPermissionKey'
if ((!(((&(reader__)))->ReadSentinel(708511156)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aPermissions = IPC::ReadParam<nsTArray<Permission>>((&(reader__)));
if (!maybe__aPermissions) {
FatalError("Error deserializing 'Permission[]'");
return MsgValueError;
}
auto& aPermissions = *maybe__aPermissions;
// Sentinel = 'aPermissions'
if ((!(((&(reader__)))->ReadSentinel(527697150)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Permission[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetPermissionsWithKey(std::move(aPermissionKey), std::move(aPermissions));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RefreshScreens__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RefreshScreens", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aScreens = IPC::ReadParam<nsTArray<ScreenDetails>>((&(reader__)));
if (!maybe__aScreens) {
FatalError("Error deserializing 'ScreenDetails[]'");
return MsgValueError;
}
auto& aScreens = *maybe__aScreens;
// Sentinel = 'aScreens'
if ((!(((&(reader__)))->ReadSentinel(234029877)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScreenDetails[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRefreshScreens(std::move(aScreens));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ShareCodeCoverageMutex__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ShareCodeCoverageMutex", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle = IPC::ReadParam<CrossProcessMutexHandle>((&(reader__)));
if (!maybe__handle) {
FatalError("Error deserializing 'CrossProcessMutexHandle'");
return MsgValueError;
}
auto& handle = *maybe__handle;
// Sentinel = 'handle'
if ((!(((&(reader__)))->ReadSentinel(142344813)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CrossProcessMutexHandle'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvShareCodeCoverageMutex(std::move(handle));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_FlushCodeCoverageCounters__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FlushCodeCoverageCounters", OTHER);
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_FlushCodeCoverageCounters(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
FlushCodeCoverageCountersResolver 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 = 'unused'
((&(writer__)))->WriteSentinel(155517589);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvFlushCodeCoverageCounters(std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetInputEventQueueEnabled__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetInputEventQueueEnabled", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetInputEventQueueEnabled();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_FlushInputEventQueue__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FlushInputEventQueue", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvFlushInputEventQueue();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ResumeInputEventQueue__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ResumeInputEventQueue", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvResumeInputEventQueue();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SuspendInputEventQueue__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SuspendInputEventQueue", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSuspendInputEventQueue();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AddDynamicScalars__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddDynamicScalars", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__definitions = IPC::ReadParam<nsTArray<DynamicScalarDefinition>>((&(reader__)));
if (!maybe__definitions) {
FatalError("Error deserializing 'DynamicScalarDefinition[]'");
return MsgValueError;
}
auto& definitions = *maybe__definitions;
// Sentinel = 'definitions'
if ((!(((&(reader__)))->ReadSentinel(455279773)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'DynamicScalarDefinition[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvAddDynamicScalars(std::move(definitions));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CrossProcessRedirect__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CrossProcessRedirect", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__args = IPC::ReadParam<RedirectToRealChannelArgs>((&(reader__)));
if (!maybe__args) {
FatalError("Error deserializing 'RedirectToRealChannelArgs'");
return MsgValueError;
}
auto& args = *maybe__args;
// Sentinel = 'args'
if ((!(((&(reader__)))->ReadSentinel(69140910)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'RedirectToRealChannelArgs'");
return MsgValueError;
}
auto maybe__aEndpoint = IPC::ReadParam<nsTArray<Endpoint<::mozilla::extensions::PStreamFilterParent>>>((&(reader__)));
if (!maybe__aEndpoint) {
FatalError("Error deserializing 'Endpoint<::mozilla::extensions::PStreamFilterParent>[]'");
return MsgValueError;
}
auto& aEndpoint = *maybe__aEndpoint;
// Sentinel = 'aEndpoint'
if ((!(((&(reader__)))->ReadSentinel(292225955)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::extensions::PStreamFilterParent>[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_CrossProcessRedirect(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
CrossProcessRedirectResolver resolver = [resolver__ = std::move(resolver__)](const nsresult& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'rv'
((&(writer__)))->WriteSentinel(22806761);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvCrossProcessRedirect(std::move(args), std::move(aEndpoint), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_StartDelayedAutoplayMediaComponents__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_StartDelayedAutoplayMediaComponents", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvStartDelayedAutoplayMediaComponents(std::move(aContext));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UpdateMediaControlAction__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateMediaControlAction", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aAction = IPC::ReadParam<MediaControlAction>((&(reader__)));
if (!maybe__aAction) {
FatalError("Error deserializing 'MediaControlAction'");
return MsgValueError;
}
auto& aAction = *maybe__aAction;
// Sentinel = 'aAction'
if ((!(((&(reader__)))->ReadSentinel(175768256)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MediaControlAction'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateMediaControlAction(std::move(aContext), std::move(aAction));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RegisterBrowsingContextGroup__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RegisterBrowsingContextGroup", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aGroupId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aGroupId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aGroupId = *maybe__aGroupId;
// Sentinel = 'aGroupId'
if ((!(((&(reader__)))->ReadSentinel(233964316)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aInits = IPC::ReadParam<nsTArray<SyncedContextInitializer>>((&(reader__)));
if (!maybe__aInits) {
FatalError("Error deserializing 'SyncedContextInitializer[]'");
return MsgValueError;
}
auto& aInits = *maybe__aInits;
// Sentinel = 'aInits'
if ((!(((&(reader__)))->ReadSentinel(134677097)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SyncedContextInitializer[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRegisterBrowsingContextGroup(std::move(aGroupId), std::move(aInits));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_DestroyBrowsingContextGroup__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_DestroyBrowsingContextGroup", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aGroupId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aGroupId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aGroupId = *maybe__aGroupId;
// Sentinel = 'aGroupId'
if ((!(((&(reader__)))->ReadSentinel(233964316)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvDestroyBrowsingContextGroup(std::move(aGroupId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_InitSandboxTesting__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitSandboxTesting", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEndpoint = IPC::ReadParam<Endpoint<::mozilla::PSandboxTestingChild>>((&(reader__)));
if (!maybe__aEndpoint) {
FatalError("Error deserializing 'Endpoint<::mozilla::PSandboxTestingChild>'");
return MsgValueError;
}
auto& aEndpoint = *maybe__aEndpoint;
// Sentinel = 'aEndpoint'
if ((!(((&(reader__)))->ReadSentinel(292225955)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PSandboxTestingChild>'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitSandboxTesting(std::move(aEndpoint));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_LoadURI__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_LoadURI", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aLoadState = IPC::ReadParam<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>((&(reader__)));
if (!maybe__aLoadState) {
FatalError("Error deserializing 'NotNull<nsDocShellLoadState>'");
return MsgValueError;
}
auto& aLoadState = *maybe__aLoadState;
// Sentinel = 'aLoadState'
if ((!(((&(reader__)))->ReadSentinel(349570019)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsDocShellLoadState>'");
return MsgValueError;
}
auto maybe__aSetNavigating = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aSetNavigating) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aSetNavigating = *maybe__aSetNavigating;
// Sentinel = 'aSetNavigating'
if ((!(((&(reader__)))->ReadSentinel(686556566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_LoadURI(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
LoadURIResolver 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("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvLoadURI(std::move(aContext), aLoadState, std::move(aSetNavigating), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_InternalLoad__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InternalLoad", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aLoadState = IPC::ReadParam<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>((&(reader__)));
if (!maybe__aLoadState) {
FatalError("Error deserializing 'NotNull<nsDocShellLoadState>'");
return MsgValueError;
}
auto& aLoadState = *maybe__aLoadState;
// Sentinel = 'aLoadState'
if ((!(((&(reader__)))->ReadSentinel(349570019)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsDocShellLoadState>'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInternalLoad(aLoadState);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_DisplayLoadError__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_DisplayLoadError", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aURI = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aURI) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aURI = *maybe__aURI;
// Sentinel = 'aURI'
if ((!(((&(reader__)))->ReadSentinel(57934162)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvDisplayLoadError(std::move(aContext), std::move(aURI));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_GoBack__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GoBack", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aCancelContentJSEpoch = IPC::ReadParam<mozilla::Maybe<int32_t>>((&(reader__)));
if (!maybe__aCancelContentJSEpoch) {
FatalError("Error deserializing 'int32_t?'");
return MsgValueError;
}
auto& aCancelContentJSEpoch = *maybe__aCancelContentJSEpoch;
// Sentinel = 'aCancelContentJSEpoch'
if ((!(((&(reader__)))->ReadSentinel(1473841167)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t?'");
return MsgValueError;
}
auto maybe__aRequireUserInteraction = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aRequireUserInteraction) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aRequireUserInteraction = *maybe__aRequireUserInteraction;
// Sentinel = 'aRequireUserInteraction'
if ((!(((&(reader__)))->ReadSentinel(1862076766)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aUserActivation = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aUserActivation) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aUserActivation = *maybe__aUserActivation;
// Sentinel = 'aUserActivation'
if ((!(((&(reader__)))->ReadSentinel(794887699)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGoBack(std::move(aContext), std::move(aCancelContentJSEpoch), std::move(aRequireUserInteraction), std::move(aUserActivation));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_GoForward__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GoForward", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aCancelContentJSEpoch = IPC::ReadParam<mozilla::Maybe<int32_t>>((&(reader__)));
if (!maybe__aCancelContentJSEpoch) {
FatalError("Error deserializing 'int32_t?'");
return MsgValueError;
}
auto& aCancelContentJSEpoch = *maybe__aCancelContentJSEpoch;
// Sentinel = 'aCancelContentJSEpoch'
if ((!(((&(reader__)))->ReadSentinel(1473841167)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t?'");
return MsgValueError;
}
auto maybe__aRequireUserInteraction = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aRequireUserInteraction) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aRequireUserInteraction = *maybe__aRequireUserInteraction;
// Sentinel = 'aRequireUserInteraction'
if ((!(((&(reader__)))->ReadSentinel(1862076766)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aUserActivation = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aUserActivation) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aUserActivation = *maybe__aUserActivation;
// Sentinel = 'aUserActivation'
if ((!(((&(reader__)))->ReadSentinel(794887699)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGoForward(std::move(aContext), std::move(aCancelContentJSEpoch), std::move(aRequireUserInteraction), std::move(aUserActivation));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_GoToIndex__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GoToIndex", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aIndex = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aIndex) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aIndex = *maybe__aIndex;
// Sentinel = 'aIndex'
if ((!(((&(reader__)))->ReadSentinel(132055642)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto maybe__aCancelContentJSEpoch = IPC::ReadParam<mozilla::Maybe<int32_t>>((&(reader__)));
if (!maybe__aCancelContentJSEpoch) {
FatalError("Error deserializing 'int32_t?'");
return MsgValueError;
}
auto& aCancelContentJSEpoch = *maybe__aCancelContentJSEpoch;
// Sentinel = 'aCancelContentJSEpoch'
if ((!(((&(reader__)))->ReadSentinel(1473841167)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t?'");
return MsgValueError;
}
auto maybe__aUserActivation = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aUserActivation) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aUserActivation = *maybe__aUserActivation;
// Sentinel = 'aUserActivation'
if ((!(((&(reader__)))->ReadSentinel(794887699)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGoToIndex(std::move(aContext), std::move(aIndex), std::move(aCancelContentJSEpoch), std::move(aUserActivation));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_Reload__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_Reload", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aReloadFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aReloadFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aReloadFlags = *maybe__aReloadFlags;
// Sentinel = 'aReloadFlags'
if ((!(((&(reader__)))->ReadSentinel(499451046)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvReload(std::move(aContext), std::move(aReloadFlags));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_StopLoad__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_StopLoad", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aStopFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aStopFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aStopFlags = *maybe__aStopFlags;
// Sentinel = 'aStopFlags'
if ((!(((&(reader__)))->ReadSentinel(360317941)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvStopLoad(std::move(aContext), std::move(aStopFlags));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_OnAllowAccessFor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_OnAllowAccessFor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aParentContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aParentContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aParentContext = *maybe__aParentContext;
// Sentinel = 'aParentContext'
if ((!(((&(reader__)))->ReadSentinel(692454833)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
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__aCookieBehavior = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aCookieBehavior) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aCookieBehavior = *maybe__aCookieBehavior;
// Sentinel = 'aCookieBehavior'
if ((!(((&(reader__)))->ReadSentinel(772408812)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aReason = IPC::ReadParam<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;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvOnAllowAccessFor(std::move(aParentContext), std::move(aTrackingOrigin), std::move(aCookieBehavior), std::move(aReason));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_OnContentBlockingDecision__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_OnContentBlockingDecision", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aReason = IPC::ReadParam<BlockingDecision>((&(reader__)));
if (!maybe__aReason) {
FatalError("Error deserializing 'BlockingDecision'");
return MsgValueError;
}
auto& aReason = *maybe__aReason;
// Sentinel = 'aReason'
if ((!(((&(reader__)))->ReadSentinel(180093642)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'BlockingDecision'");
return MsgValueError;
}
auto maybe__aRejectedReason = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aRejectedReason) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aRejectedReason = *maybe__aRejectedReason;
// Sentinel = 'aRejectedReason'
if ((!(((&(reader__)))->ReadSentinel(781059568)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvOnContentBlockingDecision(std::move(aContext), std::move(aReason), std::move(aRejectedReason));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AbortOrientationPendingPromises__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AbortOrientationPendingPromises", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvAbortOrientationPendingPromises(std::move(aContext));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_HistoryCommitIndexAndLength__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_HistoryCommitIndexAndLength", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aIndex = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aIndex) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aIndex = *maybe__aIndex;
// Sentinel = 'aIndex'
if ((!(((&(reader__)))->ReadSentinel(132055642)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aLength = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aLength) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aLength = *maybe__aLength;
// Sentinel = 'aLength'
if ((!(((&(reader__)))->ReadSentinel(179045060)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aChangeID = IPC::ReadParam<nsID>((&(reader__)));
if (!maybe__aChangeID) {
FatalError("Error deserializing 'nsID'");
return MsgValueError;
}
auto& aChangeID = *maybe__aChangeID;
// Sentinel = 'aChangeID'
if ((!(((&(reader__)))->ReadSentinel(275710773)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvHistoryCommitIndexAndLength(std::move(aContext), std::move(aIndex), std::move(aLength), std::move(aChangeID));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_GetLayoutHistoryState__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetLayoutHistoryState", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_GetLayoutHistoryState(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
GetLayoutHistoryStateResolver resolver = [resolver__ = std::move(resolver__)](std::tuple<nsILayoutHistoryState*, const mozilla::Maybe<Wireframe>&> aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), std::get<0>(aParam));
// Sentinel = 'aState'
((&(writer__)))->WriteSentinel(137036387);
IPC::WriteParam((&(writer__)), std::get<1>(aParam));
// Sentinel = 'aWireframe'
((&(writer__)))->WriteSentinel(365888516);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGetLayoutHistoryState(std::move(aContext), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_DispatchLocationChangeEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_DispatchLocationChangeEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvDispatchLocationChangeEvent(std::move(aContext));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_DispatchBeforeUnloadToSubtree__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_DispatchBeforeUnloadToSubtree", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aStartingAt = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aStartingAt) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aStartingAt = *maybe__aStartingAt;
// Sentinel = 'aStartingAt'
if ((!(((&(reader__)))->ReadSentinel(441844835)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_DispatchBeforeUnloadToSubtree(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
DispatchBeforeUnloadToSubtreeResolver resolver = [resolver__ = std::move(resolver__)](const PermitUnloadResult& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvDispatchBeforeUnloadToSubtree(std::move(aStartingAt), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UpdateMediaCodecsSupported__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateMediaCodecsSupported", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aLocation = IPC::ReadParam<RemoteDecodeIn>((&(reader__)));
if (!maybe__aLocation) {
FatalError("Error deserializing 'RemoteDecodeIn'");
return MsgValueError;
}
auto& aLocation = *maybe__aLocation;
// Sentinel = 'aLocation'
if ((!(((&(reader__)))->ReadSentinel(292094875)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'RemoteDecodeIn'");
return MsgValueError;
}
auto maybe__aSupported = IPC::ReadParam<MediaCodecsSupported>((&(reader__)));
if (!maybe__aSupported) {
FatalError("Error deserializing 'MediaCodecsSupported'");
return MsgValueError;
}
auto& aSupported = *maybe__aSupported;
// Sentinel = 'aSupported'
if ((!(((&(reader__)))->ReadSentinel(378799144)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MediaCodecsSupported'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateMediaCodecsSupported(std::move(aLocation), std::move(aSupported));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_InitNextGenLocalStorageEnabled__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitNextGenLocalStorageEnabled", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__enabled = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__enabled) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& enabled = *maybe__enabled;
// Sentinel = 'enabled'
if ((!(((&(reader__)))->ReadSentinel(188547788)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitNextGenLocalStorageEnabled(std::move(enabled));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PRemotePrintJobConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PRemotePrintJobConstructor", 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<PRemotePrintJobChild> actor = (static_cast<ContentChild*>(this))->AllocPRemotePrintJobChild();
if (!actor) {
NS_WARNING("Cannot bind null PRemotePrintJobChild actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PRemotePrintJobChild actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvPRemotePrintJobConstructor(actor);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Reply_GetLoadingSessionHistoryInfoFromParent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetLoadingSessionHistoryInfoFromParent", 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<mozilla::Maybe<LoadingSessionHistoryInfo>> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__aLoadingInfo = IPC::ReadParam<mozilla::Maybe<LoadingSessionHistoryInfo>>((&(reader__)));
if (!maybe__aLoadingInfo) {
FatalError("Error deserializing 'LoadingSessionHistoryInfo?'");
return MsgValueError;
}
auto& aLoadingInfo = *maybe__aLoadingInfo;
// Sentinel = 'aLoadingInfo'
if ((!(((&(reader__)))->ReadSentinel(500827308)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LoadingSessionHistoryInfo?'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(aLoadingInfo));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_InitStreamFilter__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitStreamFilter", 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<Endpoint<::mozilla::extensions::PStreamFilterChild>> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__aEndpoint = IPC::ReadParam<Endpoint<::mozilla::extensions::PStreamFilterChild>>((&(reader__)));
if (!maybe__aEndpoint) {
FatalError("Error deserializing 'Endpoint<::mozilla::extensions::PStreamFilterChild>'");
return MsgValueError;
}
auto& aEndpoint = *maybe__aEndpoint;
// Sentinel = 'aEndpoint'
if ((!(((&(reader__)))->ReadSentinel(292225955)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::extensions::PStreamFilterChild>'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(aEndpoint));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_PRemoteSpellcheckEngineConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_PHalConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_PHeapSnapshotTempFileHelperConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_PNeckoConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_PSpeechSynthesisConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_PMediaConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_PWebrtcGlobalConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_CreateAudioIPCConnection__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateAudioIPCConnection", 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<FileDescOrError> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__fd = IPC::ReadParam<FileDescOrError>((&(reader__)));
if (!maybe__fd) {
FatalError("Error deserializing 'FileDescOrError'");
return MsgValueError;
}
auto& fd = *maybe__fd;
// Sentinel = 'fd'
if ((!(((&(reader__)))->ReadSentinel(20054219)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FileDescOrError'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(fd));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_PURLClassifierLocalConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_PSessionStorageObserverConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_PBenchmarkStorageConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_PExternalHelperAppConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_PHandlerServiceConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_GetClipboardDataSnapshot__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetClipboardDataSnapshot", 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<ClipboardReadRequestOrError> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__aClipboardReadRequestOrError = IPC::ReadParam<ClipboardReadRequestOrError>((&(reader__)));
if (!maybe__aClipboardReadRequestOrError) {
FatalError("Error deserializing 'ClipboardReadRequestOrError'");
return MsgValueError;
}
auto& aClipboardReadRequestOrError = *maybe__aClipboardReadRequestOrError;
// Sentinel = 'aClipboardReadRequestOrError'
if ((!(((&(reader__)))->ReadSentinel(2662402850)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardReadRequestOrError'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(aClipboardReadRequestOrError));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_PClipboardWriteRequestConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_FindImageText__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FindImageText", 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<TextRecognitionResultOrError> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__result = IPC::ReadParam<TextRecognitionResultOrError>((&(reader__)));
if (!maybe__result) {
FatalError("Error deserializing 'TextRecognitionResultOrError'");
return MsgValueError;
}
auto& result = *maybe__result;
// Sentinel = 'result'
if ((!(((&(reader__)))->ReadSentinel(153223840)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TextRecognitionResultOrError'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(result));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_PContentPermissionRequestConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_CreateWindow__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateWindow", 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<CreatedWindowInfo> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__window = IPC::ReadParam<CreatedWindowInfo>((&(reader__)));
if (!maybe__window) {
FatalError("Error deserializing 'CreatedWindowInfo'");
return MsgValueError;
}
auto& window = *maybe__window;
// Sentinel = 'window'
if ((!(((&(reader__)))->ReadSentinel(152437401)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CreatedWindowInfo'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(window));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_AddCertException__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddCertException", 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<nsresult> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__success = IPC::ReadParam<nsresult>((&(reader__)));
if (!maybe__success) {
FatalError("Error deserializing 'nsresult'");
return MsgValueError;
}
auto& success = *maybe__success;
// Sentinel = 'success'
if ((!(((&(reader__)))->ReadSentinel(200082170)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(success));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_AutomaticStorageAccessPermissionCanBeGranted__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AutomaticStorageAccessPermissionCanBeGranted", 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__success = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__success) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& success = *maybe__success;
// Sentinel = 'success'
if ((!(((&(reader__)))->ReadSentinel(200082170)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(success));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_StorageAccessPermissionGrantedForOrigin__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_StorageAccessPermissionGrantedForOrigin", 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__unused = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__unused) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& unused = *maybe__unused;
// Sentinel = 'unused'
if ((!(((&(reader__)))->ReadSentinel(155517589)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(unused));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_CompleteAllowAccessFor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CompleteAllowAccessFor", 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<mozilla::Maybe<StorageAccessPromptChoices>> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__choice = IPC::ReadParam<mozilla::Maybe<StorageAccessPromptChoices>>((&(reader__)));
if (!maybe__choice) {
FatalError("Error deserializing 'StorageAccessPromptChoices?'");
return MsgValueError;
}
auto& choice = *maybe__choice;
// Sentinel = 'choice'
if ((!(((&(reader__)))->ReadSentinel(142738028)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'StorageAccessPromptChoices?'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(choice));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_SetAllowStorageAccessRequestFlag__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetAllowStorageAccessRequestFlag", 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__success = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__success) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& success = *maybe__success;
// Sentinel = 'success'
if ((!(((&(reader__)))->ReadSentinel(200082170)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(success));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_TestAllowStorageAccessRequestFlag__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_TestAllowStorageAccessRequestFlag", 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__success = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__success) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& success = *maybe__success;
// Sentinel = 'success'
if ((!(((&(reader__)))->ReadSentinel(200082170)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(success));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_TestCookiePermissionDecided__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_TestCookiePermissionDecided", 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<mozilla::Maybe<bool>> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__allowed = IPC::ReadParam<mozilla::Maybe<bool>>((&(reader__)));
if (!maybe__allowed) {
FatalError("Error deserializing 'bool?'");
return MsgValueError;
}
auto& allowed = *maybe__allowed;
// Sentinel = 'allowed'
if ((!(((&(reader__)))->ReadSentinel(195101417)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool?'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(allowed));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_TestStorageAccessPermission__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_TestStorageAccessPermission", 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<mozilla::Maybe<bool>> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__allowed = IPC::ReadParam<mozilla::Maybe<bool>>((&(reader__)));
if (!maybe__allowed) {
FatalError("Error deserializing 'bool?'");
return MsgValueError;
}
auto& allowed = *maybe__allowed;
// Sentinel = 'allowed'
if ((!(((&(reader__)))->ReadSentinel(195101417)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool?'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(allowed));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_NotifyOnHistoryReload__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyOnHistoryReload", 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<std::tuple<bool, mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>, mozilla::Maybe<bool>>> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__canReload = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__canReload) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& canReload = *maybe__canReload;
// Sentinel = 'canReload'
if ((!(((&(reader__)))->ReadSentinel(295043978)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__loadState = IPC::ReadParam<mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>>((&(reader__)));
if (!maybe__loadState) {
FatalError("Error deserializing 'NotNull<nsDocShellLoadState>?'");
return MsgValueError;
}
auto& loadState = *maybe__loadState;
// Sentinel = 'loadState'
if ((!(((&(reader__)))->ReadSentinel(304808866)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsDocShellLoadState>?'");
return MsgValueError;
}
auto maybe__reloadActiveEntry = IPC::ReadParam<mozilla::Maybe<bool>>((&(reader__)));
if (!maybe__reloadActiveEntry) {
FatalError("Error deserializing 'bool?'");
return MsgValueError;
}
auto& reloadActiveEntry = *maybe__reloadActiveEntry;
// Sentinel = 'reloadActiveEntry'
if ((!(((&(reader__)))->ReadSentinel(1029506790)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool?'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::make_tuple(std::move(canReload), std::move(loadState), std::move(reloadActiveEntry)));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_HistoryGo__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_HistoryGo", 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<mozilla::Maybe<int32_t>> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__requestedIndex = IPC::ReadParam<mozilla::Maybe<int32_t>>((&(reader__)));
if (!maybe__requestedIndex) {
FatalError("Error deserializing 'int32_t?'");
return MsgValueError;
}
auto& requestedIndex = *maybe__requestedIndex;
// Sentinel = 'requestedIndex'
if ((!(((&(reader__)))->ReadSentinel(738788811)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t?'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(requestedIndex));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_BlobURLDataRequest__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_BlobURLDataRequest", 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<BlobURLDataRequestResult> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__aResult = IPC::ReadParam<BlobURLDataRequestResult>((&(reader__)));
if (!maybe__aResult) {
FatalError("Error deserializing 'BlobURLDataRequestResult'");
return MsgValueError;
}
auto& aResult = *maybe__aResult;
// Sentinel = 'aResult'
if ((!(((&(reader__)))->ReadSentinel(185205473)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'BlobURLDataRequestResult'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(aResult));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Msg_ScriptError__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ScriptError", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__message = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__message) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& message = *maybe__message;
// Sentinel = 'message'
if ((!(((&(reader__)))->ReadSentinel(197198566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__sourceName = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__sourceName) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& sourceName = *maybe__sourceName;
// Sentinel = 'sourceName'
if ((!(((&(reader__)))->ReadSentinel(387580947)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__lineNumber = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__lineNumber) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& lineNumber = *maybe__lineNumber;
// Sentinel = 'lineNumber'
if ((!(((&(reader__)))->ReadSentinel(374932498)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__colNumber = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__colNumber) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& colNumber = *maybe__colNumber;
// Sentinel = 'colNumber'
if ((!(((&(reader__)))->ReadSentinel(304284584)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__flags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__flags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& flags = *maybe__flags;
// Sentinel = 'flags'
if ((!(((&(reader__)))->ReadSentinel(102171150)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__category = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__category) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& category = *maybe__category;
// Sentinel = 'category'
if ((!(((&(reader__)))->ReadSentinel(247333727)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__isFromPrivateWindow = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__isFromPrivateWindow) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& isFromPrivateWindow = *maybe__isFromPrivateWindow;
// Sentinel = 'isFromPrivateWindow'
if ((!(((&(reader__)))->ReadSentinel(1288964036)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__innerWindowId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__innerWindowId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& innerWindowId = *maybe__innerWindowId;
// Sentinel = 'innerWindowId'
if ((!(((&(reader__)))->ReadSentinel(627967298)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__isFromChromeContext = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__isFromChromeContext) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& isFromChromeContext = *maybe__isFromChromeContext;
// Sentinel = 'isFromChromeContext'
if ((!(((&(reader__)))->ReadSentinel(1269368756)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvScriptError(std::move(message), std::move(sourceName), std::move(lineNumber), std::move(colNumber), std::move(flags), std::move(category), std::move(isFromPrivateWindow), std::move(innerWindowId), std::move(isFromChromeContext));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ReportFrameTimingData__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReportFrameTimingData", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__loadInfo = IPC::ReadParam<LoadInfoArgs>((&(reader__)));
if (!maybe__loadInfo) {
FatalError("Error deserializing 'LoadInfoArgs'");
return MsgValueError;
}
auto& loadInfo = *maybe__loadInfo;
// Sentinel = 'loadInfo'
if ((!(((&(reader__)))->ReadSentinel(240386861)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LoadInfoArgs'");
return MsgValueError;
}
auto maybe__entryName = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__entryName) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& entryName = *maybe__entryName;
// Sentinel = 'entryName'
if ((!(((&(reader__)))->ReadSentinel(315950004)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__initiatorType = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__initiatorType) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& initiatorType = *maybe__initiatorType;
// Sentinel = 'initiatorType'
if ((!(((&(reader__)))->ReadSentinel(642647414)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aData = IPC::ReadParam<UniquePtr<PerformanceTimingData>>((&(reader__)));
if (!maybe__aData) {
FatalError("Error deserializing 'UniquePtr<PerformanceTimingData>'");
return MsgValueError;
}
auto& aData = *maybe__aData;
// Sentinel = 'aData'
if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'UniquePtr<PerformanceTimingData>'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvReportFrameTimingData(std::move(loadInfo), std::move(entryName), std::move(initiatorType), std::move(aData));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CommitBrowsingContextTransaction__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CommitBrowsingContextTransaction", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aTransaction = IPC::ReadParam<BrowsingContextTransaction>((&(reader__)));
if (!maybe__aTransaction) {
FatalError("Error deserializing 'BrowsingContextTransaction'");
return MsgValueError;
}
auto& aTransaction = *maybe__aTransaction;
// Sentinel = 'aTransaction'
if ((!(((&(reader__)))->ReadSentinel(523371752)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'BrowsingContextTransaction'");
return MsgValueError;
}
auto maybe__aEpoch = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aEpoch) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aEpoch = *maybe__aEpoch;
// Sentinel = 'aEpoch'
if ((!(((&(reader__)))->ReadSentinel(132121169)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvCommitBrowsingContextTransaction(std::move(aContext), std::move(aTransaction), std::move(aEpoch));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AsyncMessage__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::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<ContentChild*>(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 PContent::Msg_NotifyPushSubscriptionModifiedObservers__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushSubscriptionModifiedObservers", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__scope = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__scope) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& scope = *maybe__scope;
// Sentinel = 'scope'
if ((!(((&(reader__)))->ReadSentinel(107086363)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
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;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvNotifyPushSubscriptionModifiedObservers(std::move(scope), principal);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PushError__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PushError", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__scope = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__scope) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& scope = *maybe__scope;
// Sentinel = 'scope'
if ((!(((&(reader__)))->ReadSentinel(107086363)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
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__message = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__message) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& message = *maybe__message;
// Sentinel = 'message'
if ((!(((&(reader__)))->ReadSentinel(197198566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__flags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__flags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& flags = *maybe__flags;
// Sentinel = 'flags'
if ((!(((&(reader__)))->ReadSentinel(102171150)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvPushError(std::move(scope), principal, std::move(message), std::move(flags));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CreateBrowsingContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateBrowsingContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aGroupId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aGroupId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aGroupId = *maybe__aGroupId;
// Sentinel = 'aGroupId'
if ((!(((&(reader__)))->ReadSentinel(233964316)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aInit = IPC::ReadParam<BrowsingContextInitializer>((&(reader__)));
if (!maybe__aInit) {
FatalError("Error deserializing 'BrowsingContextInitializer'");
return MsgValueError;
}
auto& aInit = *maybe__aInit;
// Sentinel = 'aInit'
if ((!(((&(reader__)))->ReadSentinel(94241270)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'BrowsingContextInitializer'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvCreateBrowsingContext(std::move(aGroupId), std::move(aInit));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Reply_DiscardBrowsingContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_DiscardBrowsingContext", 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<uint64_t> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__unused = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__unused) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& unused = *maybe__unused;
// Sentinel = 'unused'
if ((!(((&(reader__)))->ReadSentinel(155517589)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(unused));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Msg_DiscardBrowsingContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_DiscardBrowsingContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aDoDiscard = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aDoDiscard) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aDoDiscard = *maybe__aDoDiscard;
// Sentinel = 'aDoDiscard'
if ((!(((&(reader__)))->ReadSentinel(339215311)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_DiscardBrowsingContext(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
DiscardBrowsingContextResolver resolver = [resolver__ = std::move(resolver__)](const uint64_t& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'unused'
((&(writer__)))->WriteSentinel(155517589);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvDiscardBrowsingContext(std::move(aContext), std::move(aDoDiscard), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AdjustWindowFocus__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AdjustWindowFocus", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aIsVisible = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aIsVisible) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aIsVisible = *maybe__aIsVisible;
// Sentinel = 'aIsVisible'
if ((!(((&(reader__)))->ReadSentinel(353567724)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aShouldClearAncestorFocus = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aShouldClearAncestorFocus) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aShouldClearAncestorFocus = *maybe__aShouldClearAncestorFocus;
// Sentinel = 'aShouldClearAncestorFocus'
if ((!(((&(reader__)))->ReadSentinel(2138442231)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aAncestorBrowsingContextToFocus = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aAncestorBrowsingContextToFocus) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aAncestorBrowsingContextToFocus = *maybe__aAncestorBrowsingContextToFocus;
// Sentinel = 'aAncestorBrowsingContextToFocus'
if ((!(((&(reader__)))->ReadSentinel(3344239764)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvAdjustWindowFocus(std::move(aContext), std::move(aIsVisible), std::move(aActionId), std::move(aShouldClearAncestorFocus), std::move(aAncestorBrowsingContextToFocus));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_WindowClose__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_WindowClose", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aTrustedCaller = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aTrustedCaller) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aTrustedCaller = *maybe__aTrustedCaller;
// Sentinel = 'aTrustedCaller'
if ((!(((&(reader__)))->ReadSentinel(706479520)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvWindowClose(std::move(aContext), std::move(aTrustedCaller));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_WindowFocus__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_WindowFocus", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
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;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvWindowFocus(std::move(aContext), std::move(aCallerType), std::move(aActionId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_WindowBlur__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_WindowBlur", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
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<ContentChild*>(this))->RecvWindowBlur(std::move(aContext), std::move(aCallerType));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RaiseWindow__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RaiseWindow", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
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;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRaiseWindow(std::move(aContext), std::move(aCallerType), std::move(aActionId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ClearFocus__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClearFocus", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvClearFocus(std::move(aContext));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetFocusedBrowsingContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetFocusedBrowsingContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetFocusedBrowsingContext(std::move(aContext), std::move(aActionId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetActiveBrowsingContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetActiveBrowsingContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetActiveBrowsingContext(std::move(aContext), std::move(aActionId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UnsetActiveBrowsingContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UnsetActiveBrowsingContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUnsetActiveBrowsingContext(std::move(aContext), std::move(aActionId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetFocusedElement__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetFocusedElement", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aNeedsFocus = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aNeedsFocus) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aNeedsFocus = *maybe__aNeedsFocus;
// Sentinel = 'aNeedsFocus'
if ((!(((&(reader__)))->ReadSentinel(419759185)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetFocusedElement(std::move(aContext), std::move(aNeedsFocus));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_FinalizeFocusOuter__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FinalizeFocusOuter", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aCanFocus = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aCanFocus) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aCanFocus = *maybe__aCanFocus;
// Sentinel = 'aCanFocus'
if ((!(((&(reader__)))->ReadSentinel(275055476)))) {
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<ContentChild*>(this))->RecvFinalizeFocusOuter(std::move(aContext), std::move(aCanFocus), std::move(aCallerType));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_BlurToChild__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_BlurToChild", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aFocusedBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aFocusedBrowsingContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aFocusedBrowsingContext = *maybe__aFocusedBrowsingContext;
// Sentinel = 'aFocusedBrowsingContext'
if ((!(((&(reader__)))->ReadSentinel(1842153819)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aBrowsingContextToClear = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aBrowsingContextToClear) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aBrowsingContextToClear = *maybe__aBrowsingContextToClear;
// Sentinel = 'aBrowsingContextToClear'
if ((!(((&(reader__)))->ReadSentinel(1859127612)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aAncestorBrowsingContextToFocus = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aAncestorBrowsingContextToFocus) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aAncestorBrowsingContextToFocus = *maybe__aAncestorBrowsingContextToFocus;
// Sentinel = 'aAncestorBrowsingContextToFocus'
if ((!(((&(reader__)))->ReadSentinel(3344239764)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aIsLeavingDocument = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aIsLeavingDocument) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aIsLeavingDocument = *maybe__aIsLeavingDocument;
// Sentinel = 'aIsLeavingDocument'
if ((!(((&(reader__)))->ReadSentinel(1103169315)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aAdjustWidget = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aAdjustWidget) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aAdjustWidget = *maybe__aAdjustWidget;
// Sentinel = 'aAdjustWidget'
if ((!(((&(reader__)))->ReadSentinel(594609457)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvBlurToChild(std::move(aFocusedBrowsingContext), std::move(aBrowsingContextToClear), std::move(aAncestorBrowsingContextToFocus), std::move(aIsLeavingDocument), std::move(aAdjustWidget), std::move(aActionId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetupFocusedAndActive__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetupFocusedAndActive", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aFocusedBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aFocusedBrowsingContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aFocusedBrowsingContext = *maybe__aFocusedBrowsingContext;
// Sentinel = 'aFocusedBrowsingContext'
if ((!(((&(reader__)))->ReadSentinel(1842153819)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aActionIdForFocused = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionIdForFocused) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionIdForFocused = *maybe__aActionIdForFocused;
// Sentinel = 'aActionIdForFocused'
if ((!(((&(reader__)))->ReadSentinel(1211303773)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aActiveBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aActiveBrowsingContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aActiveBrowsingContext = *maybe__aActiveBrowsingContext;
// Sentinel = 'aActiveBrowsingContext'
if ((!(((&(reader__)))->ReadSentinel(1678444782)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetupFocusedAndActive(std::move(aFocusedBrowsingContext), std::move(aActionIdForFocused), std::move(aActiveBrowsingContext), std::move(aActionId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ReviseActiveBrowsingContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReviseActiveBrowsingContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aOldActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aOldActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aOldActionId = *maybe__aOldActionId;
// Sentinel = 'aOldActionId'
if ((!(((&(reader__)))->ReadSentinel(490144908)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aActiveBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aActiveBrowsingContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aActiveBrowsingContext = *maybe__aActiveBrowsingContext;
// Sentinel = 'aActiveBrowsingContext'
if ((!(((&(reader__)))->ReadSentinel(1678444782)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aNewActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aNewActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aNewActionId = *maybe__aNewActionId;
// Sentinel = 'aNewActionId'
if ((!(((&(reader__)))->ReadSentinel(496043159)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvReviseActiveBrowsingContext(std::move(aOldActionId), std::move(aActiveBrowsingContext), std::move(aNewActionId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ReviseFocusedBrowsingContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReviseFocusedBrowsingContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aOldActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aOldActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aOldActionId = *maybe__aOldActionId;
// Sentinel = 'aOldActionId'
if ((!(((&(reader__)))->ReadSentinel(490144908)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aFocusedBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aFocusedBrowsingContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aFocusedBrowsingContext = *maybe__aFocusedBrowsingContext;
// Sentinel = 'aFocusedBrowsingContext'
if ((!(((&(reader__)))->ReadSentinel(1842153819)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aNewActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aNewActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aNewActionId = *maybe__aNewActionId;
// Sentinel = 'aNewActionId'
if ((!(((&(reader__)))->ReadSentinel(496043159)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvReviseFocusedBrowsingContext(std::move(aOldActionId), std::move(aFocusedBrowsingContext), std::move(aNewActionId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_MaybeExitFullscreen__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_MaybeExitFullscreen", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvMaybeExitFullscreen(std::move(aContext));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_WindowPostMessage__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_WindowPostMessage", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aMessage = IPC::ReadParam<ClonedOrErrorMessageData>((&(reader__)));
if (!maybe__aMessage) {
FatalError("Error deserializing 'ClonedOrErrorMessageData'");
return MsgValueError;
}
auto& aMessage = *maybe__aMessage;
// Sentinel = 'aMessage'
if ((!(((&(reader__)))->ReadSentinel(233440039)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClonedOrErrorMessageData'");
return MsgValueError;
}
auto maybe__aData = IPC::ReadParam<PostMessageData>((&(reader__)));
if (!maybe__aData) {
FatalError("Error deserializing 'PostMessageData'");
return MsgValueError;
}
auto& aData = *maybe__aData;
// Sentinel = 'aData'
if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PostMessageData'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvWindowPostMessage(std::move(aContext), 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 PContent::Msg_CommitWindowContextTransaction__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CommitWindowContextTransaction", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto maybe__aTransaction = IPC::ReadParam<WindowContextTransaction>((&(reader__)));
if (!maybe__aTransaction) {
FatalError("Error deserializing 'WindowContextTransaction'");
return MsgValueError;
}
auto& aTransaction = *maybe__aTransaction;
// Sentinel = 'aTransaction'
if ((!(((&(reader__)))->ReadSentinel(523371752)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WindowContextTransaction'");
return MsgValueError;
}
auto maybe__aEpoch = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aEpoch) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aEpoch = *maybe__aEpoch;
// Sentinel = 'aEpoch'
if ((!(((&(reader__)))->ReadSentinel(132121169)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvCommitWindowContextTransaction(std::move(aContext), std::move(aTransaction), std::move(aEpoch));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CreateWindowContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateWindowContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aInit = IPC::ReadParam<WindowContextInitializer>((&(reader__)));
if (!maybe__aInit) {
FatalError("Error deserializing 'WindowContextInitializer'");
return MsgValueError;
}
auto& aInit = *maybe__aInit;
// Sentinel = 'aInit'
if ((!(((&(reader__)))->ReadSentinel(94241270)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WindowContextInitializer'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvCreateWindowContext(std::move(aInit));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_DiscardWindowContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_DiscardWindowContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContextId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aContextId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aContextId = *maybe__aContextId;
// Sentinel = 'aContextId'
if ((!(((&(reader__)))->ReadSentinel(361497588)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_DiscardWindowContext(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
DiscardWindowContextResolver 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 = 'unused'
((&(writer__)))->WriteSentinel(155517589);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvDiscardWindowContext(std::move(aContextId), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_FlushFOGData__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FlushFOGData", OTHER);
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_FlushFOGData(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
FlushFOGDataResolver resolver = [resolver__ = std::move(resolver__)](ByteBuf&& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), std::move(aParam));
// Sentinel = 'buf'
((&(writer__)))->WriteSentinel(41484606);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvFlushFOGData(std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Reply_GetSystemIcon__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetSystemIcon", 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<std::tuple<nsresult, mozilla::Maybe<ByteBuf>>> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
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;
}
auto maybe__aData = IPC::ReadParam<mozilla::Maybe<ByteBuf>>((&(reader__)));
if (!maybe__aData) {
FatalError("Error deserializing 'ByteBuf?'");
return MsgValueError;
}
auto& aData = *maybe__aData;
// Sentinel = 'aData'
if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ByteBuf?'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::make_tuple(std::move(aResult), std::move(aData)));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_GetSystemGeolocationPermissionBehavior__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetSystemGeolocationPermissionBehavior", 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<SystemGeolocationPermissionBehavior> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__permission = IPC::ReadParam<SystemGeolocationPermissionBehavior>((&(reader__)));
if (!maybe__permission) {
FatalError("Error deserializing 'SystemGeolocationPermissionBehavior'");
return MsgValueError;
}
auto& permission = *maybe__permission;
// Sentinel = 'permission'
if ((!(((&(reader__)))->ReadSentinel(394921034)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SystemGeolocationPermissionBehavior'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(permission));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_RequestGeolocationPermissionFromUser__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RequestGeolocationPermissionFromUser", 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<GeolocationPermissionStatus> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__aStatus = IPC::ReadParam<GeolocationPermissionStatus>((&(reader__)));
if (!maybe__aStatus) {
FatalError("Error deserializing 'GeolocationPermissionStatus'");
return MsgValueError;
}
auto& aStatus = *maybe__aStatus;
// Sentinel = 'aStatus'
if ((!(((&(reader__)))->ReadSentinel(186712806)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'GeolocationPermissionStatus'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(aStatus));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
default:
return MsgNotKnown;
case SHMEM_CREATED_MESSAGE_TYPE:
{
if (!ShmemCreated(msg__)) {
return MsgPayloadError;
}
return MsgProcessed;
}
case SHMEM_DESTROYED_MESSAGE_TYPE:
{
if (!ShmemDestroyed(msg__)) {
return MsgPayloadError;
}
return MsgProcessed;
}
}
}
auto PContentChild::OnMessageReceived(
const Message& msg__,
UniquePtr<Message>& reply__) -> PContentChild::Result
{
int32_t route__ = msg__.routing_id();
if (MSG_ROUTING_CONTROL != route__) {
IProtocol* routed__ = Lookup(route__);
if (!routed__ || !routed__->GetLifecycleProxy()) {
return MsgRouteError;
}
RefPtr<mozilla::ipc::ActorLifecycleProxy> proxy__ =
routed__->GetLifecycleProxy();
return proxy__->Get()->OnMessageReceived(msg__, reply__);
}
return MsgNotKnown;
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::PContentChild*>::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::PContentChild*>::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, "PContent", PContentMsgStart);
if (actor.isSome()) {
return static_cast<::mozilla::dom::PContentChild*>(actor.ref());
}
return {};
}
} // namespace IPC