// // Automatically generated by ipdlc. // Edit at your own risk // #include "mozilla/dom/PContentChild.h" #include "ProfileAdditionalInformation.h" #include "ipc/ErrorIPCUtils.h" #include "ipc/MediaControlIPC.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/URLClassifierIPCUtils.h" #include "mozilla/chrome/RegistryMessageUtils.h" #include "mozilla/dom/BindingIPCUtils.h" #include "mozilla/dom/CSPMessageUtils.h" #include "mozilla/dom/ClientIPCUtils.h" #include "mozilla/dom/ConsoleReportIPCUtils.h" #include "mozilla/dom/ContentChild.h" #include "mozilla/dom/DocShellMessageUtils.h" #include "mozilla/dom/DomSecurityIPCUtils.h" #include "mozilla/dom/FetchIPCTypes.h" #include "mozilla/dom/GeolocationIPCUtils.h" #include "mozilla/dom/MediaSessionIPCUtils.h" #include "mozilla/dom/MessagePort.h" #include "mozilla/dom/NavigationAPIIPCUtils.h" #include "mozilla/dom/PageLoadEventUtils.h" #include "mozilla/dom/PermissionMessageUtils.h" #include "mozilla/dom/PermissionsPolicyUtils.h" #include "mozilla/dom/PolicyContainerMessageUtils.h" #include "mozilla/dom/PropertyBagUtils.h" #include "mozilla/dom/ReferrerInfoUtils.h" #include "mozilla/dom/RemoteType.h" #include "mozilla/dom/SessionHistoryEntry.h" #include "mozilla/dom/TabMessageUtils.h" #include "mozilla/dom/ipc/StructuredCloneData.h" #include "mozilla/dom/notification/IPCUtils.h" #include "mozilla/glean/DomMetrics.h" #include "mozilla/ipc/BigBuffer.h" #include "mozilla/ipc/ByteBufUtils.h" #include "mozilla/ipc/IPCCore.h" #include "mozilla/ipc/IPCStreamUtils.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 "nsID.h" #include "nsILayoutHistoryState.h" #include "nsIPolicyContainer.h" #include "nsIPrincipal.h" #include "nsIPropertyBag2.h" #include "nsIReferrerInfo.h" #include "nsIURI.h" #include "nsIVariant.h" #include "nsPoint.h" #include "nsStructuredCloneContainer.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/glean/PFOGTransportChild.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/PWindowGlobalChild.h" #include "mozilla/dom/PURLClassifierChild.h" #include "mozilla/dom/PURLClassifierLocalChild.h" #include "mozilla/dom/PURLClassifierLocalByNameChild.h" #include "mozilla/gfx/PVRManagerChild.h" #include "mozilla/PRemoteMediaManagerChild.h" #include "mozilla/hwinference/PSpeechRecognitionChild.h" #include "mozilla/dom/PRemoteWorkerDebuggerManagerChild.h" #include "mozilla/dom/PRemoteWorkerServiceChild.h" #include "mozilla/PProfilerChild.h" #include "mozilla/loader/PScriptCacheChild.h" #include "mozilla/dom/PSessionStorageObserverChild.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& aArr) const -> void { mManagedPBrowserChild.ToArray(aArr); } auto PContentChild::ManagedPBrowserChild() const -> const ManagedContainer& { return mManagedPBrowserChild; } auto PContentChild::ManagedPClipboardReadRequestChild(nsTArray& aArr) const -> void { mManagedPClipboardReadRequestChild.ToArray(aArr); } auto PContentChild::ManagedPClipboardReadRequestChild() const -> const ManagedContainer& { return mManagedPClipboardReadRequestChild; } auto PContentChild::ManagedPClipboardWriteRequestChild(nsTArray& aArr) const -> void { mManagedPClipboardWriteRequestChild.ToArray(aArr); } auto PContentChild::ManagedPClipboardWriteRequestChild() const -> const ManagedContainer& { return mManagedPClipboardWriteRequestChild; } auto PContentChild::ManagedPContentPermissionRequestChild(nsTArray& aArr) const -> void { mManagedPContentPermissionRequestChild.ToArray(aArr); } auto PContentChild::ManagedPContentPermissionRequestChild() const -> const ManagedContainer& { return mManagedPContentPermissionRequestChild; } auto PContentChild::ManagedPCycleCollectWithLogsChild(nsTArray& aArr) const -> void { mManagedPCycleCollectWithLogsChild.ToArray(aArr); } auto PContentChild::ManagedPCycleCollectWithLogsChild() const -> const ManagedContainer& { return mManagedPCycleCollectWithLogsChild; } auto PContentChild::ManagedPExtensionsChild(nsTArray& aArr) const -> void { mManagedPExtensionsChild.ToArray(aArr); } auto PContentChild::ManagedPExtensionsChild() const -> const ManagedContainer& { return mManagedPExtensionsChild; } auto PContentChild::ManagedPExternalHelperAppChild(nsTArray& aArr) const -> void { mManagedPExternalHelperAppChild.ToArray(aArr); } auto PContentChild::ManagedPExternalHelperAppChild() const -> const ManagedContainer& { return mManagedPExternalHelperAppChild; } auto PContentChild::ManagedPHalChild(nsTArray& aArr) const -> void { mManagedPHalChild.ToArray(aArr); } auto PContentChild::ManagedPHalChild() const -> const ManagedContainer& { return mManagedPHalChild; } auto PContentChild::ManagedPHandlerServiceChild(nsTArray& aArr) const -> void { mManagedPHandlerServiceChild.ToArray(aArr); } auto PContentChild::ManagedPHandlerServiceChild() const -> const ManagedContainer& { return mManagedPHandlerServiceChild; } auto PContentChild::ManagedPHeapSnapshotTempFileHelperChild(nsTArray& aArr) const -> void { mManagedPHeapSnapshotTempFileHelperChild.ToArray(aArr); } auto PContentChild::ManagedPHeapSnapshotTempFileHelperChild() const -> const ManagedContainer& { return mManagedPHeapSnapshotTempFileHelperChild; } auto PContentChild::ManagedPRemotePrintJobChild(nsTArray& aArr) const -> void { mManagedPRemotePrintJobChild.ToArray(aArr); } auto PContentChild::ManagedPRemotePrintJobChild() const -> const ManagedContainer& { return mManagedPRemotePrintJobChild; } auto PContentChild::ManagedPMediaChild(nsTArray& aArr) const -> void { mManagedPMediaChild.ToArray(aArr); } auto PContentChild::ManagedPMediaChild() const -> const ManagedContainer& { return mManagedPMediaChild; } auto PContentChild::ManagedPNeckoChild(nsTArray& aArr) const -> void { mManagedPNeckoChild.ToArray(aArr); } auto PContentChild::ManagedPNeckoChild() const -> const ManagedContainer& { return mManagedPNeckoChild; } auto PContentChild::ManagedPSpeechSynthesisChild(nsTArray& aArr) const -> void { mManagedPSpeechSynthesisChild.ToArray(aArr); } auto PContentChild::ManagedPSpeechSynthesisChild() const -> const ManagedContainer& { return mManagedPSpeechSynthesisChild; } auto PContentChild::ManagedPTestShellChild(nsTArray& aArr) const -> void { mManagedPTestShellChild.ToArray(aArr); } auto PContentChild::ManagedPTestShellChild() const -> const ManagedContainer& { return mManagedPTestShellChild; } auto PContentChild::ManagedPRemoteSpellcheckEngineChild(nsTArray& aArr) const -> void { mManagedPRemoteSpellcheckEngineChild.ToArray(aArr); } auto PContentChild::ManagedPRemoteSpellcheckEngineChild() const -> const ManagedContainer& { return mManagedPRemoteSpellcheckEngineChild; } auto PContentChild::ManagedPWebBrowserPersistDocumentChild(nsTArray& aArr) const -> void { mManagedPWebBrowserPersistDocumentChild.ToArray(aArr); } auto PContentChild::ManagedPWebBrowserPersistDocumentChild() const -> const ManagedContainer& { return mManagedPWebBrowserPersistDocumentChild; } auto PContentChild::ManagedPURLClassifierChild(nsTArray& aArr) const -> void { mManagedPURLClassifierChild.ToArray(aArr); } auto PContentChild::ManagedPURLClassifierChild() const -> const ManagedContainer& { return mManagedPURLClassifierChild; } auto PContentChild::ManagedPURLClassifierLocalChild(nsTArray& aArr) const -> void { mManagedPURLClassifierLocalChild.ToArray(aArr); } auto PContentChild::ManagedPURLClassifierLocalChild() const -> const ManagedContainer& { return mManagedPURLClassifierLocalChild; } auto PContentChild::ManagedPURLClassifierLocalByNameChild(nsTArray& aArr) const -> void { mManagedPURLClassifierLocalByNameChild.ToArray(aArr); } auto PContentChild::ManagedPURLClassifierLocalByNameChild() const -> const ManagedContainer& { return mManagedPURLClassifierLocalByNameChild; } auto PContentChild::ManagedPScriptCacheChild(nsTArray& aArr) const -> void { mManagedPScriptCacheChild.ToArray(aArr); } auto PContentChild::ManagedPScriptCacheChild() const -> const ManagedContainer& { return mManagedPScriptCacheChild; } auto PContentChild::ManagedPSessionStorageObserverChild(nsTArray& aArr) const -> void { mManagedPSessionStorageObserverChild.ToArray(aArr); } auto PContentChild::ManagedPSessionStorageObserverChild() const -> const ManagedContainer& { return mManagedPSessionStorageObserverChild; } auto PContentChild::ManagedProtocolIds() const -> mozilla::Span { static constexpr ::mozilla::ipc::ProtocolId sIds[] = { PBrowserMsgStart, PClipboardReadRequestMsgStart, PClipboardWriteRequestMsgStart, PContentPermissionRequestMsgStart, PCycleCollectWithLogsMsgStart, PExtensionsMsgStart, PExternalHelperAppMsgStart, PHalMsgStart, PHandlerServiceMsgStart, PHeapSnapshotTempFileHelperMsgStart, PRemotePrintJobMsgStart, PMediaMsgStart, PNeckoMsgStart, PSpeechSynthesisMsgStart, PTestShellMsgStart, PRemoteSpellcheckEngineMsgStart, PWebBrowserPersistDocumentMsgStart, PURLClassifierMsgStart, PURLClassifierLocalMsgStart, PURLClassifierLocalByNameMsgStart, PScriptCacheMsgStart, PSessionStorageObserverMsgStart }; 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 PURLClassifierMsgStart: return (&(mManagedPURLClassifierChild)); case PURLClassifierLocalMsgStart: return (&(mManagedPURLClassifierLocalChild)); case PURLClassifierLocalByNameMsgStart: return (&(mManagedPURLClassifierLocalByNameChild)); case PScriptCacheMsgStart: return (&(mManagedPScriptCacheChild)); case PSessionStorageObserverMsgStart: return (&(mManagedPSessionStorageObserverChild)); default: return nullptr; } } auto PContentChild::RejectPendingResponses(ResponseRejectReason aReason) -> void { mAsyncCallbacks.RejectPendingResponses(aReason); } auto PContentChild::OpenPBrowserEndpoint(PBrowserChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PBrowserChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PBrowserChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPBrowserEndpoint( ManagedEndpoint aEndpoint, PBrowserChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPClipboardReadRequestEndpoint(PClipboardReadRequestChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PClipboardReadRequestChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PClipboardReadRequestChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPClipboardReadRequestEndpoint( ManagedEndpoint aEndpoint, PClipboardReadRequestChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPClipboardWriteRequestEndpoint(PClipboardWriteRequestChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PClipboardWriteRequestChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PClipboardWriteRequestChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPClipboardWriteRequestEndpoint( ManagedEndpoint aEndpoint, PClipboardWriteRequestChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPContentPermissionRequestEndpoint(PContentPermissionRequestChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PContentPermissionRequestChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PContentPermissionRequestChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPContentPermissionRequestEndpoint( ManagedEndpoint aEndpoint, PContentPermissionRequestChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPCycleCollectWithLogsEndpoint(PCycleCollectWithLogsChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PCycleCollectWithLogsChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PCycleCollectWithLogsChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPCycleCollectWithLogsEndpoint( ManagedEndpoint aEndpoint, PCycleCollectWithLogsChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPExtensionsEndpoint(PExtensionsChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PExtensionsChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PExtensionsChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPExtensionsEndpoint( ManagedEndpoint aEndpoint, PExtensionsChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPExternalHelperAppEndpoint(PExternalHelperAppChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PExternalHelperAppChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PExternalHelperAppChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPExternalHelperAppEndpoint( ManagedEndpoint aEndpoint, PExternalHelperAppChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPHalEndpoint(PHalChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PHalChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PHalChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPHalEndpoint( ManagedEndpoint aEndpoint, PHalChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPHandlerServiceEndpoint(PHandlerServiceChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PHandlerServiceChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PHandlerServiceChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPHandlerServiceEndpoint( ManagedEndpoint aEndpoint, PHandlerServiceChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPHeapSnapshotTempFileHelperEndpoint(PHeapSnapshotTempFileHelperChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PHeapSnapshotTempFileHelperChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PHeapSnapshotTempFileHelperChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPHeapSnapshotTempFileHelperEndpoint( ManagedEndpoint aEndpoint, PHeapSnapshotTempFileHelperChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPRemotePrintJobEndpoint(PRemotePrintJobChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PRemotePrintJobChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PRemotePrintJobChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPRemotePrintJobEndpoint( ManagedEndpoint aEndpoint, PRemotePrintJobChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPMediaEndpoint(PMediaChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PMediaChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PMediaChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPMediaEndpoint( ManagedEndpoint aEndpoint, PMediaChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPNeckoEndpoint(PNeckoChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PNeckoChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PNeckoChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPNeckoEndpoint( ManagedEndpoint aEndpoint, PNeckoChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPSpeechSynthesisEndpoint(PSpeechSynthesisChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PSpeechSynthesisChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PSpeechSynthesisChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPSpeechSynthesisEndpoint( ManagedEndpoint aEndpoint, PSpeechSynthesisChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPTestShellEndpoint(PTestShellChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PTestShellChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PTestShellChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPTestShellEndpoint( ManagedEndpoint aEndpoint, PTestShellChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPRemoteSpellcheckEngineEndpoint(PRemoteSpellcheckEngineChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PRemoteSpellcheckEngineChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PRemoteSpellcheckEngineChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPRemoteSpellcheckEngineEndpoint( ManagedEndpoint aEndpoint, PRemoteSpellcheckEngineChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPWebBrowserPersistDocumentEndpoint(PWebBrowserPersistDocumentChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PWebBrowserPersistDocumentChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PWebBrowserPersistDocumentChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPWebBrowserPersistDocumentEndpoint( ManagedEndpoint aEndpoint, PWebBrowserPersistDocumentChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPURLClassifierEndpoint(PURLClassifierChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PURLClassifierChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PURLClassifierChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPURLClassifierEndpoint( ManagedEndpoint aEndpoint, PURLClassifierChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPURLClassifierLocalEndpoint(PURLClassifierLocalChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PURLClassifierLocalChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PURLClassifierLocalChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPURLClassifierLocalEndpoint( ManagedEndpoint aEndpoint, PURLClassifierLocalChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPURLClassifierLocalByNameEndpoint(PURLClassifierLocalByNameChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PURLClassifierLocalByNameChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PURLClassifierLocalByNameChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPURLClassifierLocalByNameEndpoint( ManagedEndpoint aEndpoint, PURLClassifierLocalByNameChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPScriptCacheEndpoint(PScriptCacheChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PScriptCacheChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PScriptCacheChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPScriptCacheEndpoint( ManagedEndpoint aEndpoint, PScriptCacheChild* aActor) -> bool { return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this); } auto PContentChild::OpenPSessionStorageObserverEndpoint(PSessionStorageObserverChild* aActor) -> ManagedEndpoint { if (!aActor) { NS_WARNING("Cannot bind null PSessionStorageObserverChild actor"); return ManagedEndpoint(); } if (!aActor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PSessionStorageObserverChild actor"); return ManagedEndpoint(); } // 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(mozilla::ipc::PrivateIPDLInterface(), aActor); } auto PContentChild::BindPSessionStorageObserverEndpoint( ManagedEndpoint aEndpoint, PSessionStorageObserverChild* 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 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 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 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 msg__ = PContent::Msg_PExtensionsConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); // 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 msg__ = PContent::Msg_PWebBrowserPersistDocumentConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); 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 JSIPCValue& aData, StructuredCloneData* aStack) -> bool { UniquePtr 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::SendUpdateScriptCacheEverHitTelemetry( const uint64_t& aChildId, const uint32_t& aRate) -> bool { UniquePtr msg__ = PContent::Msg_UpdateScriptCacheEverHitTelemetry(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), aChildId); // Sentinel = 'aChildId' ((&(writer__)))->WriteSentinel(221512435); IPC::WriteParam((&(writer__)), aRate); // Sentinel = 'aRate' ((&(writer__)))->WriteSentinel(94503406); 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_UpdateScriptCacheEverHitTelemetry", OTHER); bool sendok__ = ChannelSend(std::move(msg__)); return sendok__; } auto PContentChild::SendBecomeUntrusted() -> bool { UniquePtr msg__ = PContent::Msg_BecomeUntrusted(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_BecomeUntrusted", OTHER); bool sendok__ = ChannelSend(std::move(msg__)); return sendok__; } auto PContentChild::SendConsumeHistoryActivation(const MaybeDiscardedBrowsingContext& aTop) -> bool { UniquePtr msg__ = PContent::Msg_ConsumeHistoryActivation(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), aTop); // Sentinel = 'aTop' ((&(writer__)))->WriteSentinel(64094613); 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_ConsumeHistoryActivation", OTHER); bool sendok__ = ChannelSend(std::move(msg__)); return sendok__; } auto PContentChild::SendSynchronizeLayoutHistoryState( const MaybeDiscardedBrowsingContext& aContext, nsILayoutHistoryState* aState) -> bool { UniquePtr 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 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 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 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 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 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 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::SendAdoptChildSHEntry( const MaybeDiscardedBrowsingContext& aContext, mozilla::ipc::ResolveCallback>&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr msg__ = PContent::Msg_AdoptChildSHEntry(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_AdoptChildSHEntry", OTHER); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_AdoptChildSHEntry__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__aLoadingInfo = IPC::ReadParam>(aReader); if (!maybe__aLoadingInfo) { (aReader)->FatalError("Error deserializing 'LoadingSessionHistoryInfo?'"); return MsgValueError; } auto& aLoadingInfo = *maybe__aLoadingInfo; // Sentinel = 'aLoadingInfo' if ((!((aReader)->ReadSentinel(500827308)))) { mozilla::ipc::SentinelReadError("Error deserializing 'LoadingSessionHistoryInfo?'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(aLoadingInfo)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendAdoptChildSHEntry(const MaybeDiscardedBrowsingContext& aContext) -> RefPtr { RefPtr, ResponseRejectReason, true>::Private> promise__ = new MozPromise, ResponseRejectReason, true>::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendAdoptChildSHEntry(std::forward(aContext), [promise__](mozilla::Maybe&& aValue) { promise__->Resolve(std::move(aValue), __func__); }, [promise__](ResponseRejectReason&& aReason) { promise__->Reject(std::move(aReason), __func__); }); return promise__; } auto PContentChild::SendSynchronizeNavigationAPIState( const MaybeDiscardedBrowsingContext& aContext, mozilla::NotNull aState) -> bool { UniquePtr msg__ = PContent::Msg_SynchronizeNavigationAPIState(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_SynchronizeNavigationAPIState", OTHER); bool sendok__ = ChannelSend(std::move(msg__)); return sendok__; } auto PContentChild::SendRemoveFromBFCache(const MaybeDiscardedBrowsingContext& aContext) -> bool { UniquePtr 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 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 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 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>&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_InitStreamFilter__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__aEndpoint = IPC::ReadParam>(aReader); if (!maybe__aEndpoint) { (aReader)->FatalError("Error deserializing 'Endpoint<::mozilla::extensions::PStreamFilterChild>'"); return MsgValueError; } auto& aEndpoint = *maybe__aEndpoint; // Sentinel = 'aEndpoint' if ((!((aReader)->ReadSentinel(292225955)))) { mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::extensions::PStreamFilterChild>'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(aEndpoint)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendInitStreamFilter( const uint64_t& channelId, const nsAString& addonId) -> RefPtr { RefPtr, ResponseRejectReason, true>::Private> promise__ = new MozPromise, ResponseRejectReason, true>::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendInitStreamFilter(std::forward(channelId), std::forward(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<::mozilla::dom::ContentChild*>(this))->AllocPRemoteSpellcheckEngineChild(); return SendPRemoteSpellcheckEngineConstructor(std::forward(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 msg__ = PContent::Msg_PRemoteSpellcheckEngineConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); // 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(CrashReporterInitArgs&& aInitArgs) -> bool { UniquePtr msg__ = PContent::Msg_InitCrashReporter(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), std::move(aInitArgs)); // Sentinel = 'aInitArgs' ((&(writer__)))->WriteSentinel(286327683); 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 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 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_MARKER("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((&(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 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<::mozilla::dom::ContentChild*>(this))->AllocPHalChild(); return SendPHalConstructor(std::forward(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 msg__ = PContent::Msg_PHalConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); // 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<::mozilla::dom::ContentChild*>(this))->AllocPHeapSnapshotTempFileHelperChild(); return SendPHeapSnapshotTempFileHelperConstructor(std::forward(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 msg__ = PContent::Msg_PHeapSnapshotTempFileHelperConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); // 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 msg__ = PContent::Msg_PNeckoConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); // 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 msg__ = PContent::Msg_PSpeechSynthesisConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); // 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<::mozilla::dom::ContentChild*>(this))->AllocPMediaChild(); return SendPMediaConstructor(std::forward(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 msg__ = PContent::Msg_PMediaConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); // 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::SendCreateAudioIPCConnection( mozilla::ipc::ResolveCallback&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_CreateAudioIPCConnection__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__fd = IPC::ReadParam(aReader); if (!maybe__fd) { (aReader)->FatalError("Error deserializing 'FileDescOrError'"); return MsgValueError; } auto& fd = *maybe__fd; // Sentinel = 'fd' if ((!((aReader)->ReadSentinel(20054219)))) { mozilla::ipc::SentinelReadError("Error deserializing 'FileDescOrError'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(fd)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendCreateAudioIPCConnection() -> RefPtr { RefPtr::Private> promise__ = new MozPromise::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::SendAcquireHWInferenceProcess() -> bool { UniquePtr msg__ = PContent::Msg_AcquireHWInferenceProcess(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_AcquireHWInferenceProcess", OTHER); bool sendok__ = ChannelSend(std::move(msg__)); return sendok__; } auto PContentChild::SendCreateSpeechRecognition(Endpoint<::mozilla::hwinference::PSpeechRecognitionParent>&& endpoint) -> bool { UniquePtr msg__ = PContent::Msg_CreateSpeechRecognition(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), std::move(endpoint)); // Sentinel = 'endpoint' ((&(writer__)))->WriteSentinel(251724642); 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_CreateSpeechRecognition", OTHER); bool sendok__ = ChannelSend(std::move(msg__)); return sendok__; } auto PContentChild::SendReleaseHWInferenceConnection() -> bool { UniquePtr msg__ = PContent::Msg_ReleaseHWInferenceConnection(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_ReleaseHWInferenceConnection", OTHER); bool sendok__ = ChannelSend(std::move(msg__)); return sendok__; } auto PContentChild::SendPURLClassifierConstructor( nsIPrincipal* principal, bool* success) -> PURLClassifierChild* { PURLClassifierChild* actor = (static_cast<::mozilla::dom::ContentChild*>(this))->AllocPURLClassifierChild(principal, success); return SendPURLClassifierConstructor(std::forward(actor), std::forward(principal), std::forward(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 msg__ = PContent::Msg_PURLClassifierConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); 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 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_MARKER("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((&(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 features) -> PURLClassifierLocalChild* { PURLClassifierLocalChild* actor = (static_cast<::mozilla::dom::ContentChild*>(this))->AllocPURLClassifierLocalChild(uri, features); return SendPURLClassifierLocalConstructor(std::forward(actor), std::forward(uri), std::forward>(features)); } auto PContentChild::SendPURLClassifierLocalConstructor( PURLClassifierLocalChild* actor, nsIURI* uri, mozilla::Span 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 msg__ = PContent::Msg_PURLClassifierLocalConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); 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::SendPURLClassifierLocalByNameConstructor( nsIURI* uri, mozilla::Span featureNames, const listType& aListType) -> PURLClassifierLocalByNameChild* { PURLClassifierLocalByNameChild* actor = (static_cast<::mozilla::dom::ContentChild*>(this))->AllocPURLClassifierLocalByNameChild(uri, featureNames, aListType); return SendPURLClassifierLocalByNameConstructor(std::forward(actor), std::forward(uri), std::forward>(featureNames), std::forward(aListType)); } auto PContentChild::SendPURLClassifierLocalByNameConstructor( PURLClassifierLocalByNameChild* actor, nsIURI* uri, mozilla::Span featureNames, const listType& aListType) -> PURLClassifierLocalByNameChild* { if (!actor) { NS_WARNING("Cannot bind null PURLClassifierLocalByNameChild actor"); return nullptr; } if (!actor->SetManagerAndRegister(this)) { NS_WARNING("Failed to bind PURLClassifierLocalByNameChild actor"); return nullptr; } // Build our constructor message. UniquePtr msg__ = PContent::Msg_PURLClassifierLocalByNameConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); IPC::WriteParam((&(writer__)), uri); // Sentinel = 'uri' ((&(writer__)))->WriteSentinel(45023569); IPC::WriteParam((&(writer__)), featureNames); // Sentinel = 'featureNames' ((&(writer__)))->WriteSentinel(532350177); IPC::WriteParam((&(writer__)), aListType); // Sentinel = 'aListType' ((&(writer__)))->WriteSentinel(296158112); // 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_PURLClassifierLocalByNameConstructor", 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 PURLClassifierLocalByNameChild constructor"); actor->ActorDisconnected(FailedConstructor); return nullptr; } return actor; } auto PContentChild::SendPSessionStorageObserverConstructor() -> PSessionStorageObserverChild* { PSessionStorageObserverChild* actor = (static_cast<::mozilla::dom::ContentChild*>(this))->AllocPSessionStorageObserverChild(); return SendPSessionStorageObserverConstructor(std::forward(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 msg__ = PContent::Msg_PSessionStorageObserverConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); // 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::SendStartVisitedQueries(mozilla::Span const> uri) -> bool { UniquePtr 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 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( mozilla::NotNull uri, mozilla::NotNull triggeringPrincipal, nsIPrincipal* redirectPrincipal, const MaybeDiscardedBrowsingContext& browsingContext, const bool& wasExternallyTriggered, const bool& hasValidUserGestureActivation, const bool& newWindowTarget) -> bool { UniquePtr 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 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, mozilla::NotNull aData, nsTArray>>* retval) -> bool { UniquePtr 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 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_MARKER("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>>>((&(reader__))); if (!maybe__retval__reply) { FatalError("Error deserializing 'NotNull[]'"); return false; } auto& retval__reply = *maybe__retval__reply; // Sentinel = 'retval' if ((!(((&(reader__)))->ReadSentinel(151716495)))) { mozilla::ipc::SentinelReadError("Error deserializing 'NotNull[]'"); return false; } (*(retval)) = std::move(retval__reply); reader__.EndRead(); return true; } auto PContentChild::SendAddSecurityState( const MaybeDiscardedWindowContext& aContext, const uint32_t& aStateFlags) -> bool { UniquePtr 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::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, 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 msg__ = PContent::Msg_PExternalHelperAppConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); 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__)), 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 msg__ = PContent::Msg_PHandlerServiceConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); // 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 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 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 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 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, mozilla::NotNull stack) -> bool { UniquePtr 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 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 aTypes, const ClipboardType& aWhichClipboard, const MaybeDiscardedWindowContext& aRequestingWindowContext, IPCTransferableDataOrError* transferableDataOrError) -> bool { UniquePtr 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 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_MARKER("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((&(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::SendGetClipboardDataIfSmallerThan( mozilla::Span aTypes, const uint64_t& aThreshold, const ClipboardType& aWhichClipboard, const MaybeDiscardedWindowContext& aRequestingWindowContext, mozilla::ipc::ResolveCallback&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr msg__ = PContent::Msg_GetClipboardDataIfSmallerThan(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), aTypes); // Sentinel = 'aTypes' ((&(writer__)))->WriteSentinel(140575351); IPC::WriteParam((&(writer__)), aThreshold); // Sentinel = 'aThreshold' ((&(writer__)))->WriteSentinel(367789071); 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_GetClipboardDataIfSmallerThan", OTHER); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_GetClipboardDataIfSmallerThan__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__aResult = IPC::ReadParam(aReader); if (!maybe__aResult) { (aReader)->FatalError("Error deserializing 'IPCTransferableDataOrError'"); return MsgValueError; } auto& aResult = *maybe__aResult; // Sentinel = 'aResult' if ((!((aReader)->ReadSentinel(185205473)))) { mozilla::ipc::SentinelReadError("Error deserializing 'IPCTransferableDataOrError'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(aResult)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendGetClipboardDataIfSmallerThan( mozilla::Span aTypes, const uint64_t& aThreshold, const ClipboardType& aWhichClipboard, const MaybeDiscardedWindowContext& aRequestingWindowContext) -> RefPtr { RefPtr::Private> promise__ = new MozPromise::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendGetClipboardDataIfSmallerThan(std::forward>(aTypes), std::forward(aThreshold), std::forward(aWhichClipboard), std::forward(aRequestingWindowContext), [promise__](IPCTransferableDataOrError&& aValue) { promise__->Resolve(std::move(aValue), __func__); }, [promise__](ResponseRejectReason&& aReason) { promise__->Reject(std::move(aReason), __func__); }); return promise__; } auto PContentChild::SendGetClipboardDataSnapshot( mozilla::Span aTypes, const ClipboardType& aWhichClipboard, const MaybeDiscardedWindowContext& aRequestingWindowContext, mozilla::NotNull aRequestingPrincipal, mozilla::ipc::ResolveCallback&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_GetClipboardDataSnapshot__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__aClipboardReadRequestOrError = IPC::ReadParam(aReader); if (!maybe__aClipboardReadRequestOrError) { (aReader)->FatalError("Error deserializing 'ClipboardReadRequestOrError'"); return MsgValueError; } auto& aClipboardReadRequestOrError = *maybe__aClipboardReadRequestOrError; // Sentinel = 'aClipboardReadRequestOrError' if ((!((aReader)->ReadSentinel(2662402850)))) { mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardReadRequestOrError'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(aClipboardReadRequestOrError)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendGetClipboardDataSnapshot( mozilla::Span aTypes, const ClipboardType& aWhichClipboard, const MaybeDiscardedWindowContext& aRequestingWindowContext, mozilla::NotNull aRequestingPrincipal) -> RefPtr { RefPtr::Private> promise__ = new MozPromise::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendGetClipboardDataSnapshot(std::forward>(aTypes), std::forward(aWhichClipboard), std::forward(aRequestingWindowContext), std::forward>(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 aTypes, const ClipboardType& aWhichClipboard, const MaybeDiscardedWindowContext& aRequestingWindowContext, ClipboardReadRequestOrError* aClipboardReadRequestOrError) -> bool { UniquePtr 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 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_MARKER("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((&(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 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 aTypes, const ClipboardType& aWhichClipboard, bool* hasType) -> bool { UniquePtr 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 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_MARKER("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((&(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 msg__ = PContent::Msg_PClipboardWriteRequestConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); 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* bits) -> bool { UniquePtr 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 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_MARKER("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>((&(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 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 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 languages, mozilla::ipc::ResolveCallback&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_FindImageText__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__result = IPC::ReadParam(aReader); if (!maybe__result) { (aReader)->FatalError("Error deserializing 'TextRecognitionResultOrError'"); return MsgValueError; } auto& result = *maybe__result; // Sentinel = 'result' if ((!((aReader)->ReadSentinel(153223840)))) { mozilla::ipc::SentinelReadError("Error deserializing 'TextRecognitionResultOrError'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(result)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendFindImageText( IPCImage&& image, mozilla::Span languages) -> RefPtr { RefPtr::Private> promise__ = new MozPromise::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendFindImageText(std::forward(image), std::forward>(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 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 CrashGuardType& aGuardType, bool* crashDetected) -> bool { UniquePtr msg__ = PContent::Msg_BeginDriverCrashGuard(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), aGuardType); // Sentinel = 'aGuardType' ((&(writer__)))->WriteSentinel(356647927); UniquePtr 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_MARKER("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((&(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 CrashGuardType& aGuardType) -> bool { UniquePtr msg__ = PContent::Msg_EndDriverCrashGuard(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), aGuardType); // Sentinel = 'aGuardType' ((&(writer__)))->WriteSentinel(356647927); UniquePtr 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_MARKER("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 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 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 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 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 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 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 aRequests, nsIPrincipal* aPrincipal, nsIPrincipal* aTopLevelPrincipal, const bool& aIsHandlingUserInput, const bool& aMaybeUnsafePermissionDelegate, const TabId& tabId, const bool& aIgnoreAllowSitePermission) -> PContentPermissionRequestChild* { PContentPermissionRequestChild* actor = (static_cast<::mozilla::dom::ContentChild*>(this))->AllocPContentPermissionRequestChild(aRequests, aPrincipal, aTopLevelPrincipal, aIsHandlingUserInput, aMaybeUnsafePermissionDelegate, tabId, aIgnoreAllowSitePermission); return SendPContentPermissionRequestConstructor(std::forward(actor), std::forward>(aRequests), std::forward(aPrincipal), std::forward(aTopLevelPrincipal), std::forward(aIsHandlingUserInput), std::forward(aMaybeUnsafePermissionDelegate), std::forward(tabId), std::forward(aIgnoreAllowSitePermission)); } auto PContentChild::SendPContentPermissionRequestConstructor( PContentPermissionRequestChild* actor, mozilla::Span aRequests, nsIPrincipal* aPrincipal, nsIPrincipal* aTopLevelPrincipal, const bool& aIsHandlingUserInput, const bool& aMaybeUnsafePermissionDelegate, const TabId& tabId, const bool& aIgnoreAllowSitePermission) -> 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 msg__ = PContent::Msg_PContentPermissionRequestConstructor(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), (actor)->Id()); // Sentinel = 'actorid' ((&(writer__)))->WriteSentinel(193725159); 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); IPC::WriteParam((&(writer__)), aIgnoreAllowSitePermission); // Sentinel = 'aIgnoreAllowSitePermission' ((&(writer__)))->WriteSentinel(2328693379); // 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(ProfileAndAdditionalInformation&& aProfileAndAdditionalInformation) -> bool { UniquePtr msg__ = PContent::Msg_ShutdownProfile(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), std::move(aProfileAndAdditionalInformation)); // Sentinel = 'aProfileAndAdditionalInformation' ((&(writer__)))->WriteSentinel(3466529989); 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 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, ReadOnlySharedMemoryHandle* aHandle) -> bool { UniquePtr 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 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_MARKER("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((&(reader__))); if (!maybe__aHandle__reply) { FatalError("Error deserializing 'ReadOnlySharedMemoryHandle'"); return false; } auto& aHandle__reply = *maybe__aHandle__reply; // Sentinel = 'aHandle' if ((!(((&(reader__)))->ReadSentinel(174326446)))) { mozilla::ipc::SentinelReadError("Error deserializing 'ReadOnlySharedMemoryHandle'"); 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 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 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_MARKER("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 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 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 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 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_MARKER("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((&(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 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, ReadOnlySharedMemoryHandle* aHandle) -> bool { UniquePtr msg__ = PContent::Msg_GetHyphDict(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), aURI); // Sentinel = 'aURI' ((&(writer__)))->WriteSentinel(57934162); UniquePtr 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_MARKER("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((&(reader__))); if (!maybe__aHandle__reply) { FatalError("Error deserializing 'ReadOnlySharedMemoryHandle'"); return false; } auto& aHandle__reply = *maybe__aHandle__reply; // Sentinel = 'aHandle' if ((!(((&(reader__)))->ReadSentinel(174326446)))) { mozilla::ipc::SentinelReadError("Error deserializing 'ReadOnlySharedMemoryHandle'"); return false; } (*(aHandle)) = std::move(aHandle__reply); reader__.EndRead(); return true; } auto PContentChild::SendDropParentProcessChannelHandle(const nsID& aUuid) -> bool { UniquePtr msg__ = PContent::Msg_DropParentProcessChannelHandle(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), aUuid); // Sentinel = 'aUuid' ((&(writer__)))->WriteSentinel(97714681); 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_DropParentProcessChannelHandle", OTHER); bool sendok__ = ChannelSend(std::move(msg__)); return sendok__; } auto PContentChild::SendCreateWindow( mozilla::NotNull aThisTab, const MaybeDiscardedBrowsingContext& aParent, mozilla::NotNull 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, nsIPolicyContainer* aPolicyContainer, nsIReferrerInfo* aReferrerInfo, const OriginAttributes& aOriginAttributes, const bool& aUserActivation, const bool& aTextDirectiveUserActivation, mozilla::ipc::ResolveCallback&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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__)), aPolicyContainer); // Sentinel = 'aPolicyContainer' ((&(writer__)))->WriteSentinel(903939701); 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_CreateWindow__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__window = IPC::ReadParam(aReader); if (!maybe__window) { (aReader)->FatalError("Error deserializing 'CreatedWindowInfo'"); return MsgValueError; } auto& window = *maybe__window; // Sentinel = 'window' if ((!((aReader)->ReadSentinel(152437401)))) { mozilla::ipc::SentinelReadError("Error deserializing 'CreatedWindowInfo'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(window)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendCreateWindow( mozilla::NotNull aThisTab, const MaybeDiscardedBrowsingContext& aParent, mozilla::NotNull 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, nsIPolicyContainer* aPolicyContainer, nsIReferrerInfo* aReferrerInfo, const OriginAttributes& aOriginAttributes, const bool& aUserActivation, const bool& aTextDirectiveUserActivation) -> RefPtr { RefPtr::Private> promise__ = new MozPromise::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendCreateWindow(std::forward>(aThisTab), std::forward(aParent), std::forward>(aNewTab), std::forward(aChromeFlags), std::forward(aCalledFromJS), std::forward(aForPrinting), std::forward(aForWindowDotPrint), std::forward(aTopLevelCreatedByContent), std::forward(aURIToLoad), std::forward(aFeatures), std::forward(aModifiers), std::forward(aTriggeringPrincipal), std::forward(aPolicyContainer), std::forward(aReferrerInfo), std::forward(aOriginAttributes), std::forward(aUserActivation), std::forward(aTextDirectiveUserActivation), [promise__](CreatedWindowInfo&& aValue) { promise__->Resolve(std::move(aValue), __func__); }, [promise__](ResponseRejectReason&& aReason) { promise__->Reject(std::move(aReason), __func__); }); return promise__; } auto PContentChild::SendGetFilesRequest( const nsID& aID, mozilla::Span aDirectories, const bool& aRecursiveFlag) -> bool { UniquePtr msg__ = PContent::Msg_GetFilesRequest(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), aID); // Sentinel = 'aID' ((&(writer__)))->WriteSentinel(33292527); IPC::WriteParam((&(writer__)), aDirectories); // Sentinel = 'aDirectories' ((&(writer__)))->WriteSentinel(513803487); 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 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 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(mozilla::Span aRequests) -> bool { UniquePtr msg__ = PContent::Msg_UnstoreAndBroadcastBlobURLUnregistration(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), aRequests); // Sentinel = 'aRequests' ((&(writer__)))->WriteSentinel(301728702); 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 PageloadEventData& event, const TimeStamp& navigationStartTime, const MaybeDiscardedBrowsingContext& aBrowsingContext) -> bool { UniquePtr msg__ = PContent::Msg_RecordPageLoadEvent(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), event); // Sentinel = 'event' ((&(writer__)))->WriteSentinel(106234403); IPC::WriteParam((&(writer__)), navigationStartTime); // Sentinel = 'navigationStartTime' ((&(writer__)))->WriteSentinel(1318651854); 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_RecordPageLoadEvent", OTHER); bool sendok__ = ChannelSend(std::move(msg__)); return sendok__; } auto PContentChild::SendAccumulateChildHistograms(mozilla::Span accumulations) -> bool { UniquePtr 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 accumulations) -> bool { UniquePtr 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 updates) -> bool { UniquePtr 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 updates) -> bool { UniquePtr 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 events) -> bool { UniquePtr 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 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 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 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::SendAutomaticStorageAccessPermissionCanBeGranted( nsIPrincipal* aPrincipal, mozilla::ipc::ResolveCallback&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_AutomaticStorageAccessPermissionCanBeGranted__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__success = IPC::ReadParam(aReader); if (!maybe__success) { (aReader)->FatalError("Error deserializing 'bool'"); return MsgValueError; } auto& success = *maybe__success; // Sentinel = 'success' if ((!((aReader)->ReadSentinel(200082170)))) { mozilla::ipc::SentinelReadError("Error deserializing 'bool'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(success)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendAutomaticStorageAccessPermissionCanBeGranted(nsIPrincipal* aPrincipal) -> RefPtr { RefPtr::Private> promise__ = new MozPromise::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendAutomaticStorageAccessPermissionCanBeGranted(std::forward(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 StorageAccessPromptChoices& aAllowMode, const mozilla::Maybe& aReason, const bool& aFrameOnly, mozilla::ipc::ResolveCallback&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_StorageAccessPermissionGrantedForOrigin__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__granted = IPC::ReadParam(aReader); if (!maybe__granted) { (aReader)->FatalError("Error deserializing 'bool'"); return MsgValueError; } auto& granted = *maybe__granted; // Sentinel = 'granted' if ((!((aReader)->ReadSentinel(195756774)))) { mozilla::ipc::SentinelReadError("Error deserializing 'bool'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(granted)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendStorageAccessPermissionGrantedForOrigin( const uint64_t& aTopLevelWindowId, const MaybeDiscardedBrowsingContext& aParentContext, nsIPrincipal* aTrackingPrincipal, const nsACString& aTrackingOrigin, const StorageAccessPromptChoices& aAllowMode, const mozilla::Maybe& aReason, const bool& aFrameOnly) -> RefPtr { RefPtr::Private> promise__ = new MozPromise::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendStorageAccessPermissionGrantedForOrigin(std::forward(aTopLevelWindowId), std::forward(aParentContext), std::forward(aTrackingPrincipal), std::forward(aTrackingOrigin), std::forward(aAllowMode), std::forward&>(aReason), std::forward(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, const mozilla::Maybe& aHadPriorUserInteraction, mozilla::ipc::ResolveCallback>&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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); IPC::WriteParam((&(writer__)), aHadPriorUserInteraction); // Sentinel = 'aHadPriorUserInteraction' ((&(writer__)))->WriteSentinel(1960577434); 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_CompleteAllowAccessFor__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__choice = IPC::ReadParam>(aReader); if (!maybe__choice) { (aReader)->FatalError("Error deserializing 'StorageAccessPromptChoices?'"); return MsgValueError; } auto& choice = *maybe__choice; // Sentinel = 'choice' if ((!((aReader)->ReadSentinel(142738028)))) { mozilla::ipc::SentinelReadError("Error deserializing 'StorageAccessPromptChoices?'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(choice)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendCompleteAllowAccessFor( const MaybeDiscardedBrowsingContext& aParentContext, const uint64_t& aTopLevelWindowId, nsIPrincipal* aTrackingPrincipal, const nsACString& aTrackingOrigin, const uint32_t& aCookieBehavior, const StorageAccessPermissionGrantedReason& aReason, const mozilla::Maybe& aHadPriorUserInteraction) -> RefPtr { RefPtr, ResponseRejectReason, true>::Private> promise__ = new MozPromise, ResponseRejectReason, true>::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendCompleteAllowAccessFor(std::forward(aParentContext), std::forward(aTopLevelWindowId), std::forward(aTrackingPrincipal), std::forward(aTrackingOrigin), std::forward(aCookieBehavior), std::forward(aReason), std::forward&>(aHadPriorUserInteraction), [promise__](mozilla::Maybe&& 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 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>&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_TestCookiePermissionDecided__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__allowed = IPC::ReadParam>(aReader); if (!maybe__allowed) { (aReader)->FatalError("Error deserializing 'bool?'"); return MsgValueError; } auto& allowed = *maybe__allowed; // Sentinel = 'allowed' if ((!((aReader)->ReadSentinel(195101417)))) { mozilla::ipc::SentinelReadError("Error deserializing 'bool?'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(allowed)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendTestCookiePermissionDecided( const MaybeDiscardedBrowsingContext& aContext, nsIPrincipal* aPrincipal) -> RefPtr { RefPtr, ResponseRejectReason, true>::Private> promise__ = new MozPromise, ResponseRejectReason, true>::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendTestCookiePermissionDecided(std::forward(aContext), std::forward(aPrincipal), [promise__](mozilla::Maybe&& 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 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, const ControlType& aType, const AudioSessionType& aSessionType) -> bool { UniquePtr 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); IPC::WriteParam((&(writer__)), aType); // Sentinel = 'aType' ((&(writer__)))->WriteSentinel(99222020); IPC::WriteParam((&(writer__)), aSessionType); // Sentinel = 'aSessionType' ((&(writer__)))->WriteSentinel(526189800); 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 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 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& aMetadata) -> bool { UniquePtr 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 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 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 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& aState) -> bool { UniquePtr 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& aState) -> bool { UniquePtr 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 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 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 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 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 uint32_t& aReloadFlags, mozilla::ipc::ResolveCallback>>, mozilla::Maybe>>&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr msg__ = PContent::Msg_NotifyOnHistoryReload(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_NotifyOnHistoryReload", OTHER); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_NotifyOnHistoryReload__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__canReload = IPC::ReadParam(aReader); if (!maybe__canReload) { (aReader)->FatalError("Error deserializing 'bool'"); return MsgValueError; } auto& canReload = *maybe__canReload; // Sentinel = 'canReload' if ((!((aReader)->ReadSentinel(295043978)))) { mozilla::ipc::SentinelReadError("Error deserializing 'bool'"); return MsgValueError; } auto maybe__loadState = IPC::ReadParam>>>(aReader); if (!maybe__loadState) { (aReader)->FatalError("Error deserializing 'NotNull?'"); return MsgValueError; } auto& loadState = *maybe__loadState; // Sentinel = 'loadState' if ((!((aReader)->ReadSentinel(304808866)))) { mozilla::ipc::SentinelReadError("Error deserializing 'NotNull?'"); return MsgValueError; } auto maybe__reloadActiveEntry = IPC::ReadParam>(aReader); if (!maybe__reloadActiveEntry) { (aReader)->FatalError("Error deserializing 'bool?'"); return MsgValueError; } auto& reloadActiveEntry = *maybe__reloadActiveEntry; // Sentinel = 'reloadActiveEntry' if ((!((aReader)->ReadSentinel(1029506790)))) { mozilla::ipc::SentinelReadError("Error deserializing 'bool?'"); return MsgValueError; } aReader->EndRead(); resolve(std::make_tuple(std::move(canReload), std::move(loadState), std::move(reloadActiveEntry))); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendNotifyOnHistoryReload( const MaybeDiscardedBrowsingContext& aContext, const uint32_t& aReloadFlags) -> RefPtr { RefPtr>>, mozilla::Maybe>, ResponseRejectReason, true>::Private> promise__ = new MozPromise>>, mozilla::Maybe>, ResponseRejectReason, true>::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendNotifyOnHistoryReload(std::forward(aContext), std::forward(aReloadFlags), [promise__](std::tuple>>, mozilla::Maybe>&& 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& aCloneEntryChildren, const bool& aChannelExpired, const uint32_t& aCacheKey) -> bool { UniquePtr 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__)), 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, const bool& aCheckForCancelation, mozilla::ipc::ResolveCallback>&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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); IPC::WriteParam((&(writer__)), aCheckForCancelation); // Sentinel = 'aCheckForCancelation' ((&(writer__)))->WriteSentinel(1326581704); 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_HistoryGo__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__requestedIndex = IPC::ReadParam>(aReader); if (!maybe__requestedIndex) { (aReader)->FatalError("Error deserializing 'int32_t?'"); return MsgValueError; } auto& requestedIndex = *maybe__requestedIndex; // Sentinel = 'requestedIndex' if ((!((aReader)->ReadSentinel(738788811)))) { mozilla::ipc::SentinelReadError("Error deserializing 'int32_t?'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(requestedIndex)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendHistoryGo( const MaybeDiscardedBrowsingContext& aContext, const int32_t& aOffset, const uint64_t& aHistoryEpoch, const bool& aRequireUserInteraction, const bool& aUserActivation, const bool& aCheckForCancelation) -> RefPtr { RefPtr, ResponseRejectReason, true>::Private> promise__ = new MozPromise, ResponseRejectReason, true>::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendHistoryGo(std::forward(aContext), std::forward(aOffset), std::forward(aHistoryEpoch), std::forward(aRequireUserInteraction), std::forward(aUserActivation), std::forward(aCheckForCancelation), [promise__](mozilla::Maybe&& aValue) { promise__->Resolve(std::move(aValue), __func__); }, [promise__](ResponseRejectReason&& aReason) { promise__->Reject(std::move(aReason), __func__); }); return promise__; } auto PContentChild::SendNavigationTraverse( const MaybeDiscardedBrowsingContext& aContext, const nsID& aKey, const uint64_t& aHistoryEpoch, const bool& aUserActivation, const bool& aCheckForCancelation, mozilla::ipc::ResolveCallback&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr msg__ = PContent::Msg_NavigationTraverse(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), aContext); // Sentinel = 'aContext' ((&(writer__)))->WriteSentinel(235406151); IPC::WriteParam((&(writer__)), aKey); // Sentinel = 'aKey' ((&(writer__)))->WriteSentinel(61604235); IPC::WriteParam((&(writer__)), aHistoryEpoch); // Sentinel = 'aHistoryEpoch' ((&(writer__)))->WriteSentinel(611255619); IPC::WriteParam((&(writer__)), aUserActivation); // Sentinel = 'aUserActivation' ((&(writer__)))->WriteSentinel(794887699); IPC::WriteParam((&(writer__)), aCheckForCancelation); // Sentinel = 'aCheckForCancelation' ((&(writer__)))->WriteSentinel(1326581704); 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_NavigationTraverse", OTHER); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_NavigationTraverse__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__result = IPC::ReadParam(aReader); if (!maybe__result) { (aReader)->FatalError("Error deserializing 'nsresult'"); return MsgValueError; } auto& result = *maybe__result; // Sentinel = 'result' if ((!((aReader)->ReadSentinel(153223840)))) { mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(result)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendNavigationTraverse( const MaybeDiscardedBrowsingContext& aContext, const nsID& aKey, const uint64_t& aHistoryEpoch, const bool& aUserActivation, const bool& aCheckForCancelation) -> RefPtr { RefPtr::Private> promise__ = new MozPromise::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendNavigationTraverse(std::forward(aContext), std::forward(aKey), std::forward(aHistoryEpoch), std::forward(aUserActivation), std::forward(aCheckForCancelation), [promise__](nsresult&& 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 aTriggeringPrincipal, nsIPrincipal* aLoadingPrincipal, const OriginAttributes& aOriginAttributes, const uint64_t& aInnerWindowId, const nsACString& aPartitionKey, mozilla::ipc::ResolveCallback&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_BlobURLDataRequest__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__aResult = IPC::ReadParam(aReader); if (!maybe__aResult) { (aReader)->FatalError("Error deserializing 'BlobURLDataRequestResult'"); return MsgValueError; } auto& aResult = *maybe__aResult; // Sentinel = 'aResult' if ((!((aReader)->ReadSentinel(185205473)))) { mozilla::ipc::SentinelReadError("Error deserializing 'BlobURLDataRequestResult'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(aResult)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendBlobURLDataRequest( const nsACString& aBlobURL, mozilla::NotNull aTriggeringPrincipal, nsIPrincipal* aLoadingPrincipal, const OriginAttributes& aOriginAttributes, const uint64_t& aInnerWindowId, const nsACString& aPartitionKey) -> RefPtr { RefPtr::Private> promise__ = new MozPromise::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendBlobURLDataRequest(std::forward(aBlobURL), std::forward>(aTriggeringPrincipal), std::forward(aLoadingPrincipal), std::forward(aOriginAttributes), std::forward(aInnerWindowId), std::forward(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& previousScrollPosition, const SessionHistoryInfo& info, const uint32_t& loadType, const uint32_t& updatedCacheKey, const nsID& changeID) -> bool { UniquePtr 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 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 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 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 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 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& aData) -> bool { UniquePtr 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 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, mozilla::NotNull aData) -> bool { UniquePtr 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::SendCreateBrowsingContext( const uint64_t& aGroupId, const BrowsingContextInitializer& aInit) -> bool { UniquePtr 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&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_DiscardBrowsingContext__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__unused = IPC::ReadParam(aReader); if (!maybe__unused) { (aReader)->FatalError("Error deserializing 'uint64_t'"); return MsgValueError; } auto& unused = *maybe__unused; // Sentinel = 'unused' if ((!((aReader)->ReadSentinel(155517589)))) { mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(unused)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendDiscardBrowsingContext( const MaybeDiscardedBrowsingContext& aContext, const bool& aDoDiscard) -> RefPtr { RefPtr::Private> promise__ = new MozPromise::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendDiscardBrowsingContext(std::forward(aContext), std::forward(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 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 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 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 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 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 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 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 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 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 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 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 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 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 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, StructuredCloneData* aMessage, const PostMessageData& aData) -> bool { UniquePtr 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 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 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::SendGeckoTraceExport(ByteBuf&& aBuf) -> bool { UniquePtr msg__ = PContent::Msg_GeckoTraceExport(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), std::move(aBuf)); // Sentinel = 'aBuf' ((&(writer__)))->WriteSentinel(60686719); 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_GeckoTraceExport", OTHER); bool sendok__ = ChannelSend(std::move(msg__)); return sendok__; } auto PContentChild::SendSetContainerPermissionsPolicy( const MaybeDiscardedBrowsingContext& aContainerContext, const MaybePermissionsPolicyInfo& aContainerPermissionsPolicyInfo) -> bool { UniquePtr msg__ = PContent::Msg_SetContainerPermissionsPolicy(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), aContainerContext); // Sentinel = 'aContainerContext' ((&(writer__)))->WriteSentinel(1015744234); IPC::WriteParam((&(writer__)), aContainerPermissionsPolicyInfo); // Sentinel = 'aContainerPermissionsPolicyInfo' ((&(writer__)))->WriteSentinel(3362458781); 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_SetContainerPermissionsPolicy", OTHER); bool sendok__ = ChannelSend(std::move(msg__)); return sendok__; } auto PContentChild::SendUpdateAncestorOriginsList(const MaybeDiscardedBrowsingContext& aContext) -> bool { UniquePtr msg__ = PContent::Msg_UpdateAncestorOriginsList(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_UpdateAncestorOriginsList", OTHER); bool sendok__ = ChannelSend(std::move(msg__)); return sendok__; } auto PContentChild::SendSetReferrerPolicyForEmbedderFrame( const MaybeDiscardedBrowsingContext& aBrowsingContext, const ReferrerPolicy& aPolicy) -> bool { UniquePtr msg__ = PContent::Msg_SetReferrerPolicyForEmbedderFrame(MSG_ROUTING_CONTROL); IPC::MessageWriter writer__{ (*(msg__)), this}; IPC::WriteParam((&(writer__)), aBrowsingContext); // Sentinel = 'aBrowsingContext' ((&(writer__)))->WriteSentinel(915015314); IPC::WriteParam((&(writer__)), aPolicy); // Sentinel = 'aPolicy' ((&(writer__)))->WriteSentinel(182649554); 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_SetReferrerPolicyForEmbedderFrame", OTHER); bool sendok__ = ChannelSend(std::move(msg__)); return sendok__; } auto PContentChild::SendGetSystemIcon( nsIURI* aURI, mozilla::ipc::ResolveCallback>>&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_GetSystemIcon__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__aResult = IPC::ReadParam(aReader); if (!maybe__aResult) { (aReader)->FatalError("Error deserializing 'nsresult'"); return MsgValueError; } auto& aResult = *maybe__aResult; // Sentinel = 'aResult' if ((!((aReader)->ReadSentinel(185205473)))) { mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'"); return MsgValueError; } auto maybe__aData = IPC::ReadParam>(aReader); if (!maybe__aData) { (aReader)->FatalError("Error deserializing 'ByteBuf?'"); return MsgValueError; } auto& aData = *maybe__aData; // Sentinel = 'aData' if ((!((aReader)->ReadSentinel(90571228)))) { mozilla::ipc::SentinelReadError("Error deserializing 'ByteBuf?'"); return MsgValueError; } aReader->EndRead(); resolve(std::make_tuple(std::move(aResult), std::move(aData))); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendGetSystemIcon(nsIURI* aURI) -> RefPtr { RefPtr>, ResponseRejectReason, true>::Private> promise__ = new MozPromise>, ResponseRejectReason, true>::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendGetSystemIcon(std::forward(aURI), [promise__](std::tuple>&& aValue) { promise__->Resolve(std::move(aValue), __func__); }, [promise__](ResponseRejectReason&& aReason) { promise__->Reject(std::move(aReason), __func__); }); return promise__; } auto PContentChild::SendGetSystemGeolocationPermissionBehavior( mozilla::ipc::ResolveCallback&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_GetSystemGeolocationPermissionBehavior__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__permission = IPC::ReadParam(aReader); if (!maybe__permission) { (aReader)->FatalError("Error deserializing 'SystemGeolocationPermissionBehavior'"); return MsgValueError; } auto& permission = *maybe__permission; // Sentinel = 'permission' if ((!((aReader)->ReadSentinel(394921034)))) { mozilla::ipc::SentinelReadError("Error deserializing 'SystemGeolocationPermissionBehavior'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(permission)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendGetSystemGeolocationPermissionBehavior() -> RefPtr { RefPtr::Private> promise__ = new MozPromise::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&& aResolve, mozilla::ipc::RejectCallback&& aReject) -> void { UniquePtr 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); IPC::Message::seqno_t seqno__ = 0; if (ChannelSend(std::move(msg__), (&(seqno__)))) { mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_RequestGeolocationPermissionFromUser__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable { auto maybe__aStatus = IPC::ReadParam(aReader); if (!maybe__aStatus) { (aReader)->FatalError("Error deserializing 'GeolocationPermissionStatus'"); return MsgValueError; } auto& aStatus = *maybe__aStatus; // Sentinel = 'aStatus' if ((!((aReader)->ReadSentinel(186712806)))) { mozilla::ipc::SentinelReadError("Error deserializing 'GeolocationPermissionStatus'"); return MsgValueError; } aReader->EndRead(); resolve(std::move(aStatus)); return MsgProcessed; }, std::move(aReject)); } else { aReject(::mozilla::ipc::ResponseRejectReason::SendError); } return; } auto PContentChild::SendRequestGeolocationPermissionFromUser(const MaybeDiscardedBrowsingContext& aBrowsingContext) -> RefPtr { RefPtr::Private> promise__ = new MozPromise::Private(__func__); promise__->UseDirectTaskDispatch(__func__); SendRequestGeolocationPermissionFromUser(std::forward(aBrowsingContext), [promise__](GeolocationPermissionStatus&& aValue) { promise__->Resolve(std::move(aValue), __func__); }, [promise__](ResponseRejectReason&& aReason) { promise__->Reject(std::move(aReason), __func__); }); return promise__; } auto PContentChild::DeallocManagee( mozilla::ipc::ProtocolId aProtocolId, IProtocol* aListener) -> void { switch (aProtocolId) { case PContentPermissionRequestMsgStart: static_cast<::mozilla::dom::ContentChild*>(this)->DeallocPContentPermissionRequestChild(static_cast(aListener)); return; case PCycleCollectWithLogsMsgStart: static_cast<::mozilla::dom::ContentChild*>(this)->DeallocPCycleCollectWithLogsChild(static_cast(aListener)); return; case PHalMsgStart: static_cast<::mozilla::dom::ContentChild*>(this)->DeallocPHalChild(static_cast(aListener)); return; case PHeapSnapshotTempFileHelperMsgStart: static_cast<::mozilla::dom::ContentChild*>(this)->DeallocPHeapSnapshotTempFileHelperChild(static_cast(aListener)); return; case PMediaMsgStart: static_cast<::mozilla::dom::ContentChild*>(this)->DeallocPMediaChild(static_cast(aListener)); return; case PRemoteSpellcheckEngineMsgStart: static_cast<::mozilla::dom::ContentChild*>(this)->DeallocPRemoteSpellcheckEngineChild(static_cast(aListener)); return; case PURLClassifierMsgStart: static_cast<::mozilla::dom::ContentChild*>(this)->DeallocPURLClassifierChild(static_cast(aListener)); return; case PURLClassifierLocalMsgStart: static_cast<::mozilla::dom::ContentChild*>(this)->DeallocPURLClassifierLocalChild(static_cast(aListener)); return; case PURLClassifierLocalByNameMsgStart: static_cast<::mozilla::dom::ContentChild*>(this)->DeallocPURLClassifierLocalByNameChild(static_cast(aListener)); return; case PScriptCacheMsgStart: static_cast<::mozilla::dom::ContentChild*>(this)->DeallocPScriptCacheChild(static_cast(aListener)); return; case PSessionStorageObserverMsgStart: static_cast<::mozilla::dom::ContentChild*>(this)->DeallocPSessionStorageObserverChild(static_cast(aListener)); return; default: FatalError("unreached"); return; } } auto PContentChild::OnMessageReceived(const Message& msg__) -> PContentChild::Result { if (!CanSend()) { 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; } IPC::Message::routeid_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 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>((&(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>((&(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((&(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((&(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((&(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((&(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((&(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((&(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((&(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<::mozilla::dom::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__actorid__ = IPC::ReadParam((&(reader__))); if (!maybe__actorid__) { FatalError("Error deserializing 'mozilla::ipc::ActorId'"); return MsgValueError; } auto& actorid__ = *maybe__actorid__; // Sentinel = 'actorid' if ((!(((&(reader__)))->ReadSentinel(193725159)))) { mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'"); return MsgValueError; } auto maybe__aBrowser = IPC::ReadParam((&(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((&(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(); // Ensure the ID which was sent to us is valid, and reserve a spot // in the table for the new actor before we bother to alloc it. if (!ToplevelProtocol()->TryReserve(actorid__)) { NS_WARNING("Failed to reserve ActorId for constructor"); return MsgValueError; } RefPtr actor = (static_cast<::mozilla::dom::ContentChild*>(this))->AllocPWebBrowserPersistDocumentChild(aBrowser, aContext); if (!actor) { NS_WARNING("Alloc function returned null"); // Clean up the reservation taken above if this fails, to avoid // leaving zombie entries in the map. ToplevelProtocol()->ClearReservation(actorid__); return MsgValueError; } // NOTE: SetManagerAndRegister unconditionally consumes the // reservation taken by TryReserve, so we don't need to clear it on // failure. if (!actor->SetManagerAndRegister(this, actorid__)) { NS_WARNING("Failed to set manager for constructor"); return MsgValueError; } mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::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((&(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((&(reader__))); if (!maybe__aData) { FatalError("Error deserializing 'JSIPCValue'"); return MsgValueError; } auto& aData = *maybe__aData; // Sentinel = 'aData' if ((!(((&(reader__)))->ReadSentinel(90571228)))) { mozilla::ipc::SentinelReadError("Error deserializing 'JSIPCValue'"); return MsgValueError; } auto maybe__aStack = IPC::ReadParam>((&(reader__))); if (!maybe__aStack) { FatalError("Error deserializing 'StructuredCloneData'"); return MsgValueError; } auto& aStack = *maybe__aStack; // Sentinel = 'aStack' if ((!(((&(reader__)))->ReadSentinel(135201368)))) { mozilla::ipc::SentinelReadError("Error deserializing 'StructuredCloneData'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvRawMessage(std::move(aMetadata), std::move(aData), 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>((&(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<::mozilla::dom::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>((&(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<::mozilla::dom::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>((&(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<::mozilla::dom::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>((&(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>((&(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>((&(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>((&(reader__))); if (!maybe__video) { FatalError("Error deserializing 'Endpoint<::mozilla::PRemoteMediaManagerChild>'"); return MsgValueError; } auto& video = *maybe__video; // Sentinel = 'video' if ((!(((&(reader__)))->ReadSentinel(106693144)))) { mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PRemoteMediaManagerChild>'"); return MsgValueError; } auto maybe__namespaces = IPC::ReadParam>((&(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<::mozilla::dom::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>((&(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>((&(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>((&(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>((&(reader__))); if (!maybe__video) { FatalError("Error deserializing 'Endpoint<::mozilla::PRemoteMediaManagerChild>'"); return MsgValueError; } auto& video = *maybe__video; // Sentinel = 'video' if ((!(((&(reader__)))->ReadSentinel(106693144)))) { mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PRemoteMediaManagerChild>'"); return MsgValueError; } auto maybe__namespaces = IPC::ReadParam>((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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<::mozilla::dom::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<::mozilla::dom::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>((&(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<::mozilla::dom::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((&(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((&(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((&(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>((&(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(); mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL; UniquePtr reply__(PContent::Reply_RequestMemoryReport(id__)); reply__->set_seqno(msg__.seqno()); RefPtr 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<::mozilla::dom::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_DecodeImage__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_DecodeImage", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__aURI = IPC::ReadParam>>((&(reader__))); if (!maybe__aURI) { FatalError("Error deserializing 'NotNull'"); return MsgValueError; } auto& aURI = *maybe__aURI; // Sentinel = 'aURI' if ((!(((&(reader__)))->ReadSentinel(57934162)))) { mozilla::ipc::SentinelReadError("Error deserializing 'NotNull'"); return MsgValueError; } auto maybe__aSize = IPC::ReadParam((&(reader__))); if (!maybe__aSize) { FatalError("Error deserializing 'ImageIntSize'"); return MsgValueError; } auto& aSize = *maybe__aSize; // Sentinel = 'aSize' if ((!(((&(reader__)))->ReadSentinel(97124861)))) { mozilla::ipc::SentinelReadError("Error deserializing 'ImageIntSize'"); return MsgValueError; } auto maybe__aStretch = IPC::ReadParam((&(reader__))); if (!maybe__aStretch) { FatalError("Error deserializing 'bool'"); return MsgValueError; } auto& aStretch = *maybe__aStretch; // Sentinel = 'aStretch' if ((!(((&(reader__)))->ReadSentinel(241500991)))) { mozilla::ipc::SentinelReadError("Error deserializing 'bool'"); return MsgValueError; } auto maybe__aColorScheme = IPC::ReadParam((&(reader__))); if (!maybe__aColorScheme) { FatalError("Error deserializing 'ColorScheme'"); return MsgValueError; } auto& aColorScheme = *maybe__aColorScheme; // Sentinel = 'aColorScheme' if ((!(((&(reader__)))->ReadSentinel(505414838)))) { mozilla::ipc::SentinelReadError("Error deserializing 'ColorScheme'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL; UniquePtr reply__(PContent::Reply_DecodeImage(id__)); reply__->set_seqno(msg__.seqno()); RefPtr resolver__ = new mozilla::ipc::IPDLResolverInner(std::move(reply__), this); DecodeImageResolver resolver = [resolver__ = std::move(resolver__)](std::tuple&&> aParam) { resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) { IPC::MessageWriter writer__(*reply__, self__); IPC::WriteParam((&(writer__)), std::get<0>(aParam)); // Sentinel = 'rv' ((&(writer__)))->WriteSentinel(22806761); IPC::WriteParam((&(writer__)), std::move(std::get<1>(aParam))); // Sentinel = 'image' ((&(writer__)))->WriteSentinel(102498820); 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<::mozilla::dom::ContentChild*>(this))->RecvDecodeImage(aURI, std::move(aSize), std::move(aStretch), std::move(aColorScheme), 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((&(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((&(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<::mozilla::dom::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__actorid__ = IPC::ReadParam((&(reader__))); if (!maybe__actorid__) { FatalError("Error deserializing 'mozilla::ipc::ActorId'"); return MsgValueError; } auto& actorid__ = *maybe__actorid__; // Sentinel = 'actorid' if ((!(((&(reader__)))->ReadSentinel(193725159)))) { mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'"); return MsgValueError; } auto maybe__dumpAllTraces = IPC::ReadParam((&(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((&(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((&(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(); // Ensure the ID which was sent to us is valid, and reserve a spot // in the table for the new actor before we bother to alloc it. if (!ToplevelProtocol()->TryReserve(actorid__)) { NS_WARNING("Failed to reserve ActorId for constructor"); return MsgValueError; } PCycleCollectWithLogsChild* actor = (static_cast<::mozilla::dom::ContentChild*>(this))->AllocPCycleCollectWithLogsChild(dumpAllTraces, gcLog, ccLog); if (!actor) { NS_WARNING("Alloc function returned null"); // Clean up the reservation taken above if this fails, to avoid // leaving zombie entries in the map. ToplevelProtocol()->ClearReservation(actorid__); return MsgValueError; } // NOTE: SetManagerAndRegister unconditionally consumes the // reservation taken by TryReserve, so we don't need to clear it on // failure. if (!actor->SetManagerAndRegister(this, actorid__)) { NS_WARNING("Failed to set manager for constructor"); return MsgValueError; } mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::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__actorid__ = IPC::ReadParam((&(reader__))); if (!maybe__actorid__) { FatalError("Error deserializing 'mozilla::ipc::ActorId'"); return MsgValueError; } auto& actorid__ = *maybe__actorid__; // Sentinel = 'actorid' if ((!(((&(reader__)))->ReadSentinel(193725159)))) { mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'"); return MsgValueError; } reader__.EndRead(); // Ensure the ID which was sent to us is valid, and reserve a spot // in the table for the new actor before we bother to alloc it. if (!ToplevelProtocol()->TryReserve(actorid__)) { NS_WARNING("Failed to reserve ActorId for constructor"); return MsgValueError; } RefPtr actor = (static_cast<::mozilla::dom::ContentChild*>(this))->AllocPTestShellChild(); if (!actor) { NS_WARNING("Alloc function returned null"); // Clean up the reservation taken above if this fails, to avoid // leaving zombie entries in the map. ToplevelProtocol()->ClearReservation(actorid__); return MsgValueError; } // NOTE: SetManagerAndRegister unconditionally consumes the // reservation taken by TryReserve, so we don't need to clear it on // failure. if (!actor->SetManagerAndRegister(this, actorid__)) { NS_WARNING("Failed to set manager for constructor"); return MsgValueError; } mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::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__actorid__ = IPC::ReadParam((&(reader__))); if (!maybe__actorid__) { FatalError("Error deserializing 'mozilla::ipc::ActorId'"); return MsgValueError; } auto& actorid__ = *maybe__actorid__; // Sentinel = 'actorid' if ((!(((&(reader__)))->ReadSentinel(193725159)))) { mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'"); return MsgValueError; } auto maybe__cacheFile = IPC::ReadParam((&(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((&(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(); // Ensure the ID which was sent to us is valid, and reserve a spot // in the table for the new actor before we bother to alloc it. if (!ToplevelProtocol()->TryReserve(actorid__)) { NS_WARNING("Failed to reserve ActorId for constructor"); return MsgValueError; } PScriptCacheChild* actor = (static_cast<::mozilla::dom::ContentChild*>(this))->AllocPScriptCacheChild(cacheFile, wantCacheData); if (!actor) { NS_WARNING("Alloc function returned null"); // Clean up the reservation taken above if this fails, to avoid // leaving zombie entries in the map. ToplevelProtocol()->ClearReservation(actorid__); return MsgValueError; } // NOTE: SetManagerAndRegister unconditionally consumes the // reservation taken by TryReserve, so we don't need to clear it on // failure. if (!actor->SetManagerAndRegister(this, actorid__)) { NS_WARNING("Failed to set manager for constructor"); return MsgValueError; } mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::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>((&(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>((&(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>((&(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((&(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((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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_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>((&(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__aChrome = IPC::ReadParam>((&(reader__))); if (!maybe__aChrome) { FatalError("Error deserializing 'bool?'"); return MsgValueError; } auto& aChrome = *maybe__aChrome; // Sentinel = 'aChrome' if ((!(((&(reader__)))->ReadSentinel(177996480)))) { mozilla::ipc::SentinelReadError("Error deserializing 'bool?'"); return MsgValueError; } auto maybe__aPrincipal = IPC::ReadParam>>((&(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__aSchemelessSite = IPC::ReadParam>((&(reader__))); if (!maybe__aSchemelessSite) { FatalError("Error deserializing 'nsCString?'"); return MsgValueError; } auto& aSchemelessSite = *maybe__aSchemelessSite; // Sentinel = 'aSchemelessSite' if ((!(((&(reader__)))->ReadSentinel(792528387)))) { mozilla::ipc::SentinelReadError("Error deserializing 'nsCString?'"); return MsgValueError; } auto maybe__aPattern = IPC::ReadParam>((&(reader__))); if (!maybe__aPattern) { FatalError("Error deserializing 'OriginAttributesPattern?'"); return MsgValueError; } auto& aPattern = *maybe__aPattern; // Sentinel = 'aPattern' if ((!(((&(reader__)))->ReadSentinel(236651328)))) { mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributesPattern?'"); return MsgValueError; } auto maybe__aURL = IPC::ReadParam>((&(reader__))); if (!maybe__aURL) { FatalError("Error deserializing 'nsCString?'"); return MsgValueError; } auto& aURL = *maybe__aURL; // Sentinel = 'aURL' if ((!(((&(reader__)))->ReadSentinel(58130773)))) { mozilla::ipc::SentinelReadError("Error deserializing 'nsCString?'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvClearImageCache(std::move(privateLoader), std::move(aChrome), std::move(aPrincipal), std::move(aSchemelessSite), std::move(aPattern), std::move(aURL)); 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__aChrome = IPC::ReadParam>((&(reader__))); if (!maybe__aChrome) { FatalError("Error deserializing 'bool?'"); return MsgValueError; } auto& aChrome = *maybe__aChrome; // Sentinel = 'aChrome' if ((!(((&(reader__)))->ReadSentinel(177996480)))) { mozilla::ipc::SentinelReadError("Error deserializing 'bool?'"); return MsgValueError; } auto maybe__aPrincipal = IPC::ReadParam>>((&(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__aSchemelessSite = IPC::ReadParam>((&(reader__))); if (!maybe__aSchemelessSite) { FatalError("Error deserializing 'nsCString?'"); return MsgValueError; } auto& aSchemelessSite = *maybe__aSchemelessSite; // Sentinel = 'aSchemelessSite' if ((!(((&(reader__)))->ReadSentinel(792528387)))) { mozilla::ipc::SentinelReadError("Error deserializing 'nsCString?'"); return MsgValueError; } auto maybe__aPattern = IPC::ReadParam>((&(reader__))); if (!maybe__aPattern) { FatalError("Error deserializing 'OriginAttributesPattern?'"); return MsgValueError; } auto& aPattern = *maybe__aPattern; // Sentinel = 'aPattern' if ((!(((&(reader__)))->ReadSentinel(236651328)))) { mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributesPattern?'"); return MsgValueError; } auto maybe__aURL = IPC::ReadParam>((&(reader__))); if (!maybe__aURL) { FatalError("Error deserializing 'nsCString?'"); return MsgValueError; } auto& aURL = *maybe__aURL; // Sentinel = 'aURL' if ((!(((&(reader__)))->ReadSentinel(58130773)))) { mozilla::ipc::SentinelReadError("Error deserializing 'nsCString?'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvClearStyleSheetCache(std::move(aChrome), std::move(aPrincipal), std::move(aSchemelessSite), std::move(aPattern), std::move(aURL)); 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__aChrome = IPC::ReadParam>((&(reader__))); if (!maybe__aChrome) { FatalError("Error deserializing 'bool?'"); return MsgValueError; } auto& aChrome = *maybe__aChrome; // Sentinel = 'aChrome' if ((!(((&(reader__)))->ReadSentinel(177996480)))) { mozilla::ipc::SentinelReadError("Error deserializing 'bool?'"); return MsgValueError; } auto maybe__aPrincipal = IPC::ReadParam>>((&(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__aSchemelessSite = IPC::ReadParam>((&(reader__))); if (!maybe__aSchemelessSite) { FatalError("Error deserializing 'nsCString?'"); return MsgValueError; } auto& aSchemelessSite = *maybe__aSchemelessSite; // Sentinel = 'aSchemelessSite' if ((!(((&(reader__)))->ReadSentinel(792528387)))) { mozilla::ipc::SentinelReadError("Error deserializing 'nsCString?'"); return MsgValueError; } auto maybe__aPattern = IPC::ReadParam>((&(reader__))); if (!maybe__aPattern) { FatalError("Error deserializing 'OriginAttributesPattern?'"); return MsgValueError; } auto& aPattern = *maybe__aPattern; // Sentinel = 'aPattern' if ((!(((&(reader__)))->ReadSentinel(236651328)))) { mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributesPattern?'"); return MsgValueError; } auto maybe__aURL = IPC::ReadParam>((&(reader__))); if (!maybe__aURL) { FatalError("Error deserializing 'nsCString?'"); return MsgValueError; } auto& aURL = *maybe__aURL; // Sentinel = 'aURL' if ((!(((&(reader__)))->ReadSentinel(58130773)))) { mozilla::ipc::SentinelReadError("Error deserializing 'nsCString?'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvClearScriptCache(std::move(aChrome), std::move(aPrincipal), std::move(aSchemelessSite), std::move(aPattern), std::move(aURL)); if ((!(__ok))) { mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!"); // Error handled in mozilla::ipc::IPCResult return MsgProcessingError; } return MsgProcessed; } case PContent::Msg_InvalidateScriptCache__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_InvalidateScriptCache", OTHER); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvInvalidateScriptCache(); 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((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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((&(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((&(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<::mozilla::dom::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>((&(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<::mozilla::dom::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((&(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((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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>((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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); mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL; UniquePtr reply__(PContent::Reply_CollectPerfStatsJSON(id__)); reply__->set_seqno(msg__.seqno()); RefPtr 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<::mozilla::dom::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); mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL; UniquePtr reply__(PContent::Reply_CollectScrollingMetrics(id__)); reply__->set_seqno(msg__.seqno()); RefPtr resolver__ = new mozilla::ipc::IPDLResolverInner(std::move(reply__), this); CollectScrollingMetricsResolver resolver = [resolver__ = std::move(resolver__)](std::tuple 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<::mozilla::dom::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_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>((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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>((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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_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__aFlags = IPC::ReadParam((&(reader__))); if (!maybe__aFlags) { FatalError("Error deserializing 'GlobalReflowFlags'"); return MsgValueError; } auto& aFlags = *maybe__aFlags; // Sentinel = 'aFlags' if ((!(((&(reader__)))->ReadSentinel(129892943)))) { mozilla::ipc::SentinelReadError("Error deserializing 'GlobalReflowFlags'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvForceGlobalReflow(std::move(aFlags)); 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((&(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((&(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((&(reader__))); if (!maybe__aHandle) { FatalError("Error deserializing 'ReadOnlySharedMemoryHandle'"); return MsgValueError; } auto& aHandle = *maybe__aHandle; // Sentinel = 'aHandle' if ((!(((&(reader__)))->ReadSentinel(174326446)))) { mozilla::ipc::SentinelReadError("Error deserializing 'ReadOnlySharedMemoryHandle'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::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>((&(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<::mozilla::dom::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>((&(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<::mozilla::dom::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<::mozilla::dom::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>((&(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<::mozilla::dom::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>((&(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<::mozilla::dom::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_SimpleURIUnknownRemoteSchemes__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_SimpleURIUnknownRemoteSchemes", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__remoteSchemes = IPC::ReadParam>((&(reader__))); if (!maybe__remoteSchemes) { FatalError("Error deserializing 'nsCString[]'"); return MsgValueError; } auto& remoteSchemes = *maybe__remoteSchemes; // Sentinel = 'remoteSchemes' if ((!(((&(reader__)))->ReadSentinel(629867861)))) { mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvSimpleURIUnknownRemoteSchemes(std::move(remoteSchemes)); 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__aMapHandle = IPC::ReadParam((&(reader__))); if (!maybe__aMapHandle) { FatalError("Error deserializing 'ReadOnlySharedMemoryHandle'"); return MsgValueError; } auto& aMapHandle = *maybe__aMapHandle; // Sentinel = 'aMapHandle' if ((!(((&(reader__)))->ReadSentinel(341246924)))) { mozilla::ipc::SentinelReadError("Error deserializing 'ReadOnlySharedMemoryHandle'"); return MsgValueError; } auto maybe__blobs = IPC::ReadParam>((&(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>((&(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<::mozilla::dom::ContentChild*>(this))->RecvUpdateSharedData(std::move(aMapHandle), 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((&(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<::mozilla::dom::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<::mozilla::dom::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_SetBrowserPermission__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_SetBrowserPermission", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__origin = IPC::ReadParam((&(reader__))); if (!maybe__origin) { FatalError("Error deserializing 'nsCString'"); return MsgValueError; } auto& origin = *maybe__origin; // Sentinel = 'origin' if ((!(((&(reader__)))->ReadSentinel(150143625)))) { mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'"); return MsgValueError; } auto maybe__type = IPC::ReadParam((&(reader__))); if (!maybe__type) { FatalError("Error deserializing 'nsCString'"); return MsgValueError; } auto& type = *maybe__type; // Sentinel = 'type' if ((!(((&(reader__)))->ReadSentinel(75760067)))) { mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'"); return MsgValueError; } auto maybe__action = IPC::ReadParam((&(reader__))); if (!maybe__action) { FatalError("Error deserializing 'uint32_t'"); return MsgValueError; } auto& action = *maybe__action; // Sentinel = 'action' if ((!(((&(reader__)))->ReadSentinel(143786623)))) { mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'"); return MsgValueError; } auto maybe__browserId = IPC::ReadParam((&(reader__))); if (!maybe__browserId) { FatalError("Error deserializing 'uint64_t'"); return MsgValueError; } auto& browserId = *maybe__browserId; // Sentinel = 'browserId' if ((!(((&(reader__)))->ReadSentinel(318571442)))) { mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'"); return MsgValueError; } auto maybe__isRemoval = IPC::ReadParam((&(reader__))); if (!maybe__isRemoval) { FatalError("Error deserializing 'bool'"); return MsgValueError; } auto& isRemoval = *maybe__isRemoval; // Sentinel = 'isRemoval' if ((!(((&(reader__)))->ReadSentinel(307954611)))) { mozilla::ipc::SentinelReadError("Error deserializing 'bool'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvSetBrowserPermission(std::move(origin), std::move(type), std::move(action), std::move(browserId), std::move(isRemoval)); if ((!(__ok))) { mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!"); // Error handled in mozilla::ipc::IPCResult return MsgProcessingError; } return MsgProcessed; } case PContent::Msg_ClearBrowserPermissions__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_ClearBrowserPermissions", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__browserId = IPC::ReadParam((&(reader__))); if (!maybe__browserId) { FatalError("Error deserializing 'uint64_t'"); return MsgValueError; } auto& browserId = *maybe__browserId; // Sentinel = 'browserId' if ((!(((&(reader__)))->ReadSentinel(318571442)))) { mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'"); return MsgValueError; } auto maybe__actionFilter = IPC::ReadParam((&(reader__))); if (!maybe__actionFilter) { FatalError("Error deserializing 'uint32_t'"); return MsgValueError; } auto& actionFilter = *maybe__actionFilter; // Sentinel = 'actionFilter' if ((!(((&(reader__)))->ReadSentinel(528811237)))) { mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvClearBrowserPermissions(std::move(browserId), std::move(actionFilter)); if ((!(__ok))) { mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!"); // Error handled in mozilla::ipc::IPCResult return MsgProcessingError; } return MsgProcessed; } case PContent::Msg_MemoryPressure__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_MemoryPressure", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__reason = IPC::ReadParam((&(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<::mozilla::dom::ContentChild*>(this))->RecvMemoryPressure(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_MemoryPressureStop__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_MemoryPressureStop", OTHER); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvMemoryPressureStop(); 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<::mozilla::dom::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<::mozilla::dom::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<::mozilla::dom::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<::mozilla::dom::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<::mozilla::dom::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((&(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<::mozilla::dom::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<::mozilla::dom::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((&(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<::mozilla::dom::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((&(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((&(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((&(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((&(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((&(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((&(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((&(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((&(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<::mozilla::dom::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_SetRemoteType__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_SetRemoteType", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__aRemoteType = IPC::ReadParam((&(reader__))); if (!maybe__aRemoteType) { FatalError("Error deserializing 'RemoteType'"); return MsgValueError; } auto& aRemoteType = *maybe__aRemoteType; // Sentinel = 'aRemoteType' if ((!(((&(reader__)))->ReadSentinel(437847152)))) { mozilla::ipc::SentinelReadError("Error deserializing 'RemoteType'"); return MsgValueError; } auto maybe__aProfile = IPC::ReadParam((&(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<::mozilla::dom::ContentChild*>(this))->RecvSetRemoteType(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_AddLoadedOrigin__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_AddLoadedOrigin", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__aPrincipal = IPC::ReadParam>>((&(reader__))); if (!maybe__aPrincipal) { FatalError("Error deserializing 'NotNull'"); return MsgValueError; } auto& aPrincipal = *maybe__aPrincipal; // Sentinel = 'aPrincipal' if ((!(((&(reader__)))->ReadSentinel(364381188)))) { mozilla::ipc::SentinelReadError("Error deserializing 'NotNull'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvAddLoadedOrigin(aPrincipal); 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>((&(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; } auto maybe__aDebuggerChildEp = IPC::ReadParam>((&(reader__))); if (!maybe__aDebuggerChildEp) { FatalError("Error deserializing 'Endpoint<::mozilla::dom::PRemoteWorkerDebuggerManagerChild>'"); return MsgValueError; } auto& aDebuggerChildEp = *maybe__aDebuggerChildEp; // Sentinel = 'aDebuggerChildEp' if ((!(((&(reader__)))->ReadSentinel(869271072)))) { mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::dom::PRemoteWorkerDebuggerManagerChild>'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvInitRemoteWorkerService(std::move(aEndpoint), std::move(aDebuggerChildEp)); 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>((&(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<::mozilla::dom::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>((&(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>((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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((&(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>>((&(reader__))); if (!maybe__initialData) { FatalError("Error deserializing 'NotNull'"); return MsgValueError; } auto& initialData = *maybe__initialData; // Sentinel = 'initialData' if ((!(((&(reader__)))->ReadSentinel(451413093)))) { mozilla::ipc::SentinelReadError("Error deserializing 'NotNull'"); return MsgValueError; } auto maybe__lookAndFeeldata = IPC::ReadParam((&(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((&(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>((&(reader__))); if (!maybe__sharedUASheetHandle) { FatalError("Error deserializing 'ReadOnlySharedMemoryHandle?'"); return MsgValueError; } auto& sharedUASheetHandle = *maybe__sharedUASheetHandle; // Sentinel = 'sharedUASheetHandle' if ((!(((&(reader__)))->ReadSentinel(1232406355)))) { mozilla::ipc::SentinelReadError("Error deserializing 'ReadOnlySharedMemoryHandle?'"); return MsgValueError; } auto maybe__sharedUASheetAddress = IPC::ReadParam((&(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>((&(reader__))); if (!maybe__sharedFontListBlocks) { FatalError("Error deserializing 'ReadOnlySharedMemoryHandle[]'"); return MsgValueError; } auto& sharedFontListBlocks = *maybe__sharedFontListBlocks; // Sentinel = 'sharedFontListBlocks' if ((!(((&(reader__)))->ReadSentinel(1412827145)))) { mozilla::ipc::SentinelReadError("Error deserializing 'ReadOnlySharedMemoryHandle[]'"); return MsgValueError; } auto maybe__aIsStartingUp = IPC::ReadParam((&(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<::mozilla::dom::ContentChild*>(this))->RecvSetXPCOMProcessAttributes(std::move(xpcomInit), 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<::mozilla::dom::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((&(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<::mozilla::dom::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<::mozilla::dom::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>((&(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((&(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<::mozilla::dom::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>((&(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((&(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<::mozilla::dom::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((&(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((&(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((&(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<::mozilla::dom::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((&(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((&(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>((&(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<::mozilla::dom::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_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<::mozilla::dom::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((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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<::mozilla::dom::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_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((&(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((&(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<::mozilla::dom::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((&(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__aPrincipal = IPC::ReadParam>((&(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((&(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<::mozilla::dom::ContentChild*>(this))->RecvBlobURLRegistration(std::move(aURI), 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__aURIs = IPC::ReadParam>((&(reader__))); if (!maybe__aURIs) { FatalError("Error deserializing 'nsCString[]'"); return MsgValueError; } auto& aURIs = *maybe__aURIs; // Sentinel = 'aURIs' if ((!(((&(reader__)))->ReadSentinel(87622085)))) { mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvBlobURLUnregistration(std::move(aURIs)); 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>((&(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<::mozilla::dom::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((&(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((&(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<::mozilla::dom::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((&(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>((&(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<::mozilla::dom::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>((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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); mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL; UniquePtr reply__(PContent::Reply_FlushCodeCoverageCounters(id__)); reply__->set_seqno(msg__.seqno()); RefPtr 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<::mozilla::dom::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<::mozilla::dom::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<::mozilla::dom::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<::mozilla::dom::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<::mozilla::dom::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>((&(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<::mozilla::dom::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((&(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>>((&(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(); mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL; UniquePtr reply__(PContent::Reply_CrossProcessRedirect(id__)); reply__->set_seqno(msg__.seqno()); RefPtr 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<::mozilla::dom::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((&(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<::mozilla::dom::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((&(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((&(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<::mozilla::dom::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_UpdateMediaSessionInterrupt__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_UpdateMediaSessionInterrupt", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__aContext = IPC::ReadParam((&(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((&(reader__))); if (!maybe__aAction) { FatalError("Error deserializing 'AudioFocusInterruptAction'"); return MsgValueError; } auto& aAction = *maybe__aAction; // Sentinel = 'aAction' if ((!(((&(reader__)))->ReadSentinel(175768256)))) { mozilla::ipc::SentinelReadError("Error deserializing 'AudioFocusInterruptAction'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvUpdateMediaSessionInterrupt(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((&(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>((&(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; } auto maybe__aUseOriginAgentCluster = IPC::ReadParam>((&(reader__))); if (!maybe__aUseOriginAgentCluster) { FatalError("Error deserializing 'OriginAgentClusterInitializer[]'"); return MsgValueError; } auto& aUseOriginAgentCluster = *maybe__aUseOriginAgentCluster; // Sentinel = 'aUseOriginAgentCluster' if ((!(((&(reader__)))->ReadSentinel(1658849480)))) { mozilla::ipc::SentinelReadError("Error deserializing 'OriginAgentClusterInitializer[]'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvRegisterBrowsingContextGroup(std::move(aGroupId), std::move(aInits), std::move(aUseOriginAgentCluster)); 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((&(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<::mozilla::dom::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_SetUseOriginAgentCluster__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_SetUseOriginAgentCluster", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__aGroupId = IPC::ReadParam((&(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__aPrincipal = IPC::ReadParam>>((&(reader__))); if (!maybe__aPrincipal) { FatalError("Error deserializing 'NotNull'"); return MsgValueError; } auto& aPrincipal = *maybe__aPrincipal; // Sentinel = 'aPrincipal' if ((!(((&(reader__)))->ReadSentinel(364381188)))) { mozilla::ipc::SentinelReadError("Error deserializing 'NotNull'"); return MsgValueError; } auto maybe__aUseOriginAgentCluster = IPC::ReadParam((&(reader__))); if (!maybe__aUseOriginAgentCluster) { FatalError("Error deserializing 'bool'"); return MsgValueError; } auto& aUseOriginAgentCluster = *maybe__aUseOriginAgentCluster; // Sentinel = 'aUseOriginAgentCluster' if ((!(((&(reader__)))->ReadSentinel(1658849480)))) { mozilla::ipc::SentinelReadError("Error deserializing 'bool'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvSetUseOriginAgentCluster(std::move(aGroupId), aPrincipal, std::move(aUseOriginAgentCluster)); 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((&(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>>((&(reader__))); if (!maybe__aLoadState) { FatalError("Error deserializing 'NotNull'"); return MsgValueError; } auto& aLoadState = *maybe__aLoadState; // Sentinel = 'aLoadState' if ((!(((&(reader__)))->ReadSentinel(349570019)))) { mozilla::ipc::SentinelReadError("Error deserializing 'NotNull'"); return MsgValueError; } auto maybe__aSetNavigating = IPC::ReadParam((&(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(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvLoadURI(std::move(aContext), aLoadState, std::move(aSetNavigating)); 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>>((&(reader__))); if (!maybe__aLoadState) { FatalError("Error deserializing 'NotNull'"); return MsgValueError; } auto& aLoadState = *maybe__aLoadState; // Sentinel = 'aLoadState' if ((!(((&(reader__)))->ReadSentinel(349570019)))) { mozilla::ipc::SentinelReadError("Error deserializing 'NotNull'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::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((&(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((&(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<::mozilla::dom::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((&(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>((&(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((&(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((&(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<::mozilla::dom::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((&(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>((&(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((&(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((&(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<::mozilla::dom::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((&(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((&(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>((&(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((&(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<::mozilla::dom::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((&(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((&(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<::mozilla::dom::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((&(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((&(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<::mozilla::dom::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_DeactivateDocuments__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_DeactivateDocuments", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__aContext = IPC::ReadParam((&(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<::mozilla::dom::ContentChild*>(this))->RecvDeactivateDocuments(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_ReactivateDocuments__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_ReactivateDocuments", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__aContext = IPC::ReadParam((&(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__aReactivatedEntry = IPC::ReadParam>((&(reader__))); if (!maybe__aReactivatedEntry) { FatalError("Error deserializing 'SessionHistoryInfo?'"); return MsgValueError; } auto& aReactivatedEntry = *maybe__aReactivatedEntry; // Sentinel = 'aReactivatedEntry' if ((!(((&(reader__)))->ReadSentinel(1012860640)))) { mozilla::ipc::SentinelReadError("Error deserializing 'SessionHistoryInfo?'"); return MsgValueError; } auto maybe__aNewSHEs = IPC::ReadParam>((&(reader__))); if (!maybe__aNewSHEs) { FatalError("Error deserializing 'SessionHistoryInfo[]'"); return MsgValueError; } auto& aNewSHEs = *maybe__aNewSHEs; // Sentinel = 'aNewSHEs' if ((!(((&(reader__)))->ReadSentinel(218366687)))) { mozilla::ipc::SentinelReadError("Error deserializing 'SessionHistoryInfo[]'"); return MsgValueError; } auto maybe__aPreviousEntryForActivation = IPC::ReadParam>((&(reader__))); if (!maybe__aPreviousEntryForActivation) { FatalError("Error deserializing 'PreviousSessionHistoryInfo?'"); return MsgValueError; } auto& aPreviousEntryForActivation = *maybe__aPreviousEntryForActivation; // Sentinel = 'aPreviousEntryForActivation' if ((!(((&(reader__)))->ReadSentinel(2572684042)))) { mozilla::ipc::SentinelReadError("Error deserializing 'PreviousSessionHistoryInfo?'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvReactivateDocuments(std::move(aContext), std::move(aReactivatedEntry), std::move(aNewSHEs), std::move(aPreviousEntryForActivation)); 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((&(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((&(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((&(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((&(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<::mozilla::dom::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((&(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((&(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((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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((&(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((&(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((&(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((&(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; } auto maybe__aTruncations = IPC::ReadParam>((&(reader__))); if (!maybe__aTruncations) { FatalError("Error deserializing 'NavigationEntriesTruncation[]'"); return MsgValueError; } auto& aTruncations = *maybe__aTruncations; // Sentinel = 'aTruncations' if ((!(((&(reader__)))->ReadSentinel(531891452)))) { mozilla::ipc::SentinelReadError("Error deserializing 'NavigationEntriesTruncation[]'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvHistoryCommitIndexAndLength(std::move(aContext), std::move(aIndex), std::move(aLength), std::move(aChangeID), std::move(aTruncations)); 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((&(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::ActorId id__ = MSG_ROUTING_CONTROL; UniquePtr reply__(PContent::Reply_GetLayoutHistoryState(id__)); reply__->set_seqno(msg__.seqno()); RefPtr resolver__ = new mozilla::ipc::IPDLResolverInner(std::move(reply__), this); GetLayoutHistoryStateResolver resolver = [resolver__ = std::move(resolver__)](std::tuple&> 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<::mozilla::dom::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((&(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<::mozilla::dom::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((&(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; } auto maybe__info = IPC::ReadParam>>>((&(reader__))); if (!maybe__info) { FatalError("Error deserializing 'NotNull?'"); return MsgValueError; } auto& info = *maybe__info; // Sentinel = 'info' if ((!(((&(reader__)))->ReadSentinel(70058413)))) { mozilla::ipc::SentinelReadError("Error deserializing 'NotNull?'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL; UniquePtr reply__(PContent::Reply_DispatchBeforeUnloadToSubtree(id__)); reply__->set_seqno(msg__.seqno()); RefPtr 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<::mozilla::dom::ContentChild*>(this))->RecvDispatchBeforeUnloadToSubtree(std::move(aStartingAt), std::move(info), 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_DispatchNavigateToTraversable__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_DispatchNavigateToTraversable", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__aTraversable = IPC::ReadParam((&(reader__))); if (!maybe__aTraversable) { FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'"); return MsgValueError; } auto& aTraversable = *maybe__aTraversable; // Sentinel = 'aTraversable' if ((!(((&(reader__)))->ReadSentinel(525731037)))) { mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'"); return MsgValueError; } auto maybe__info = IPC::ReadParam>>((&(reader__))); if (!maybe__info) { FatalError("Error deserializing 'NotNull'"); return MsgValueError; } auto& info = *maybe__info; // Sentinel = 'info' if ((!(((&(reader__)))->ReadSentinel(70058413)))) { mozilla::ipc::SentinelReadError("Error deserializing 'NotNull'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL; UniquePtr reply__(PContent::Reply_DispatchNavigateToTraversable(id__)); reply__->set_seqno(msg__.seqno()); RefPtr resolver__ = new mozilla::ipc::IPDLResolverInner(std::move(reply__), this); DispatchNavigateToTraversableResolver 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<::mozilla::dom::ContentChild*>(this))->RecvDispatchNavigateToTraversable(std::move(aTraversable), info, 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((&(reader__))); if (!maybe__aLocation) { FatalError("Error deserializing 'RemoteMediaIn'"); return MsgValueError; } auto& aLocation = *maybe__aLocation; // Sentinel = 'aLocation' if ((!(((&(reader__)))->ReadSentinel(292094875)))) { mozilla::ipc::SentinelReadError("Error deserializing 'RemoteMediaIn'"); return MsgValueError; } auto maybe__aSupported = IPC::ReadParam((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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__actorid__ = IPC::ReadParam((&(reader__))); if (!maybe__actorid__) { FatalError("Error deserializing 'mozilla::ipc::ActorId'"); return MsgValueError; } auto& actorid__ = *maybe__actorid__; // Sentinel = 'actorid' if ((!(((&(reader__)))->ReadSentinel(193725159)))) { mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'"); return MsgValueError; } reader__.EndRead(); // Ensure the ID which was sent to us is valid, and reserve a spot // in the table for the new actor before we bother to alloc it. if (!ToplevelProtocol()->TryReserve(actorid__)) { NS_WARNING("Failed to reserve ActorId for constructor"); return MsgValueError; } RefPtr actor = (static_cast<::mozilla::dom::ContentChild*>(this))->AllocPRemotePrintJobChild(); if (!actor) { NS_WARNING("Alloc function returned null"); // Clean up the reservation taken above if this fails, to avoid // leaving zombie entries in the map. ToplevelProtocol()->ClearReservation(actorid__); return MsgValueError; } // NOTE: SetManagerAndRegister unconditionally consumes the // reservation taken by TryReserve, so we don't need to clear it on // failure. if (!actor->SetManagerAndRegister(this, actorid__)) { NS_WARNING("Failed to set manager for constructor"); return MsgValueError; } mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::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::Msg_ConsumeHistoryActivation__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_ConsumeHistoryActivation", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__aTop = IPC::ReadParam((&(reader__))); if (!maybe__aTop) { FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'"); return MsgValueError; } auto& aTop = *maybe__aTop; // Sentinel = 'aTop' if ((!(((&(reader__)))->ReadSentinel(64094613)))) { mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvConsumeHistoryActivation(std::move(aTop)); if ((!(__ok))) { mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!"); // Error handled in mozilla::ipc::IPCResult return MsgProcessingError; } return MsgProcessed; } case PContent::Reply_AdoptChildSHEntry__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_AdoptChildSHEntry", OTHER); return mAsyncCallbacks.GotReply(this, msg__); } 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); return mAsyncCallbacks.GotReply(this, msg__); } 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_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); return mAsyncCallbacks.GotReply(this, msg__); } case PContent::Reply_PURLClassifierLocalConstructor__ID: { return MsgProcessed; } case PContent::Reply_PURLClassifierLocalByNameConstructor__ID: { return MsgProcessed; } case PContent::Reply_PSessionStorageObserverConstructor__ID: { return MsgProcessed; } case PContent::Reply_PExternalHelperAppConstructor__ID: { return MsgProcessed; } case PContent::Reply_PHandlerServiceConstructor__ID: { return MsgProcessed; } case PContent::Reply_GetClipboardDataIfSmallerThan__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_GetClipboardDataIfSmallerThan", OTHER); return mAsyncCallbacks.GotReply(this, msg__); } 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); return mAsyncCallbacks.GotReply(this, msg__); } 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); return mAsyncCallbacks.GotReply(this, msg__); } 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); return mAsyncCallbacks.GotReply(this, msg__); } 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); return mAsyncCallbacks.GotReply(this, msg__); } 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); return mAsyncCallbacks.GotReply(this, msg__); } 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); return mAsyncCallbacks.GotReply(this, msg__); } 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); return mAsyncCallbacks.GotReply(this, msg__); } 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); return mAsyncCallbacks.GotReply(this, msg__); } 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); return mAsyncCallbacks.GotReply(this, msg__); } case PContent::Reply_NavigationTraverse__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_NavigationTraverse", OTHER); return mAsyncCallbacks.GotReply(this, msg__); } 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); return mAsyncCallbacks.GotReply(this, msg__); } 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((&(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((&(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((&(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((&(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((&(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((&(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((&(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((&(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((&(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<::mozilla::dom::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((&(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((&(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((&(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>((&(reader__))); if (!maybe__aData) { FatalError("Error deserializing 'UniquePtr'"); return MsgValueError; } auto& aData = *maybe__aData; // Sentinel = 'aData' if ((!(((&(reader__)))->ReadSentinel(90571228)))) { mozilla::ipc::SentinelReadError("Error deserializing 'UniquePtr'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::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((&(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((&(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((&(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<::mozilla::dom::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((&(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>>((&(reader__))); if (!maybe__aData) { FatalError("Error deserializing 'NotNull'"); return MsgValueError; } auto& aData = *maybe__aData; // Sentinel = 'aData' if ((!(((&(reader__)))->ReadSentinel(90571228)))) { mozilla::ipc::SentinelReadError("Error deserializing 'NotNull'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvAsyncMessage(std::move(aMessage), aData); 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((&(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((&(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<::mozilla::dom::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); return mAsyncCallbacks.GotReply(this, msg__); } 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((&(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((&(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(); mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL; UniquePtr reply__(PContent::Reply_DiscardBrowsingContext(id__)); reply__->set_seqno(msg__.seqno()); RefPtr 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<::mozilla::dom::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((&(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((&(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((&(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((&(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((&(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<::mozilla::dom::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((&(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((&(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<::mozilla::dom::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((&(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((&(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((&(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<::mozilla::dom::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((&(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((&(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<::mozilla::dom::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((&(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((&(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((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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((&(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((&(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<::mozilla::dom::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((&(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((&(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<::mozilla::dom::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((&(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((&(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<::mozilla::dom::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((&(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((&(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<::mozilla::dom::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((&(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((&(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((&(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<::mozilla::dom::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((&(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((&(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((&(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((&(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((&(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((&(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<::mozilla::dom::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((&(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((&(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((&(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((&(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<::mozilla::dom::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((&(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((&(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((&(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<::mozilla::dom::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((&(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((&(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((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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((&(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>((&(reader__))); if (!maybe__aMessage) { FatalError("Error deserializing 'StructuredCloneData'"); return MsgValueError; } auto& aMessage = *maybe__aMessage; // Sentinel = 'aMessage' if ((!(((&(reader__)))->ReadSentinel(233440039)))) { mozilla::ipc::SentinelReadError("Error deserializing 'StructuredCloneData'"); return MsgValueError; } auto maybe__aData = IPC::ReadParam((&(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<::mozilla::dom::ContentChild*>(this))->RecvWindowPostMessage(std::move(aContext), 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((&(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((&(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((&(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<::mozilla::dom::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((&(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<::mozilla::dom::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((&(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(); mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL; UniquePtr reply__(PContent::Reply_DiscardWindowContext(id__)); reply__->set_seqno(msg__.seqno()); RefPtr 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<::mozilla::dom::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_CreateFOGTransport__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_CreateFOGTransport", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__aChildEndpoint = IPC::ReadParam>((&(reader__))); if (!maybe__aChildEndpoint) { FatalError("Error deserializing 'Endpoint<::mozilla::glean::PFOGTransportChild>'"); return MsgValueError; } auto& aChildEndpoint = *maybe__aChildEndpoint; // Sentinel = 'aChildEndpoint' if ((!(((&(reader__)))->ReadSentinel(668665223)))) { mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::glean::PFOGTransportChild>'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvCreateFOGTransport(std::move(aChildEndpoint)); 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); mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL; UniquePtr reply__(PContent::Reply_FlushFOGData(id__)); reply__->set_seqno(msg__.seqno()); RefPtr 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<::mozilla::dom::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::Msg_SystemPermissionChanged__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_SystemPermissionChanged", OTHER); IPC::MessageReader reader__{ msg__, this}; auto maybe__aName = IPC::ReadParam((&(reader__))); if (!maybe__aName) { FatalError("Error deserializing 'PermissionName'"); return MsgValueError; } auto& aName = *maybe__aName; // Sentinel = 'aName' if ((!(((&(reader__)))->ReadSentinel(92537315)))) { mozilla::ipc::SentinelReadError("Error deserializing 'PermissionName'"); return MsgValueError; } auto maybe__aState = IPC::ReadParam((&(reader__))); if (!maybe__aState) { FatalError("Error deserializing 'PermissionState'"); return MsgValueError; } auto& aState = *maybe__aState; // Sentinel = 'aState' if ((!(((&(reader__)))->ReadSentinel(137036387)))) { mozilla::ipc::SentinelReadError("Error deserializing 'PermissionState'"); return MsgValueError; } reader__.EndRead(); mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentChild*>(this))->RecvSystemPermissionChanged(std::move(aName), std::move(aState)); 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); return mAsyncCallbacks.GotReply(this, msg__); } 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); return mAsyncCallbacks.GotReply(this, msg__); } 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); return mAsyncCallbacks.GotReply(this, msg__); } 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& reply__) -> PContentChild::Result { if (!CanSend()) { return MsgDropped; } IPC::Message::routeid_t route__ = msg__.routing_id(); if (MSG_ROUTING_CONTROL != route__) { IProtocol* routed__ = Lookup(route__); if (!routed__ || !routed__->GetLifecycleProxy()) { return MsgDropped; } RefPtr proxy__ = routed__->GetLifecycleProxy(); return proxy__->Get()->OnMessageReceived(msg__, reply__); } return MsgNotKnown; } } // namespace dom } // namespace mozilla