mozilla-central/__GENERATED__/__macosx64-aarch64__/ipc/ipdl/PContentParent.cpp (file symbol)

Copy as Markdown

Other Tools

//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/PContentParent.h"
#include "ipc/ErrorIPCUtils.h"
#include "ipc/MediaControlIPC.h"
#include "mozilla/AlertNotificationIPCSerializer.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/D3DMessageUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/PermissionDelegateIPCUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/RemoteLazyInputStream.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/chrome/RegistryMessageUtils.h"
#include "mozilla/dom/BindingIPCUtils.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/ClientIPCUtils.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/dom/FeaturePolicyUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/GeolocationIPCUtils.h"
#include "mozilla/dom/MediaSessionIPCUtils.h"
#include "mozilla/dom/MessagePort.h"
#include "mozilla/dom/PageLoadEventUtils.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/SessionHistoryEntry.h"
#include "mozilla/dom/TabMessageUtils.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"
#include "mozilla/glean/GleanMetrics.h"
#include "mozilla/ipc/BigBuffer.h"
#include "mozilla/ipc/ByteBufUtils.h"
#include "mozilla/ipc/IPCCore.h"
#include "mozilla/ipc/IPCStreamUtils.h"
#include "mozilla/ipc/SerializedStructuredCloneBuffer.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/CompositorTypes.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/net/CacheInfoIPCTypes.h"
#include "mozilla/net/ClassOfService.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "mozilla/widget/WidgetMessageUtils.h"
#include "nsDOMNavigationTiming.h"
#include "nsDocShellLoadState.h"
#include "nsGeoPositionIPCSerialiser.h"
#include "nsHttp.h"
#include "nsHttpResponseHead.h"
#include "nsIContentSecurityPolicy.h"
#include "nsID.h"
#include "nsILayoutHistoryState.h"
#include "nsIPrincipal.h"
#include "nsIPropertyBag2.h"
#include "nsIReferrerInfo.h"
#include "nsITransportSecurityInfo.h"
#include "nsIURI.h"
#include "nsIVariant.h"
#include "nsIX509Cert.h"
#include "nsPoint.h"
#include "mozilla/ipc/PBackgroundStarterParent.h"
#include "mozilla/dom/PBrowserParent.h"
#include "mozilla/PClipboardContentAnalysisParent.h"
#include "mozilla/PClipboardReadRequestParent.h"
#include "mozilla/PClipboardWriteRequestParent.h"
#include "mozilla/layers/PCompositorManagerParent.h"
#include "mozilla/dom/PContentPermissionRequestParent.h"
#include "mozilla/dom/PCycleCollectWithLogsParent.h"
#include "mozilla/net/PDocumentChannelParent.h"
#include "mozilla/extensions/PExtensionsParent.h"
#include "mozilla/dom/PExternalHelperAppParent.h"
#include "mozilla/dom/PHandlerServiceParent.h"
#include "mozilla/hal_sandbox/PHalParent.h"
#include "mozilla/devtools/PHeapSnapshotTempFileHelperParent.h"
#include "mozilla/PProcessHangMonitorParent.h"
#include "mozilla/layers/PImageBridgeParent.h"
#include "mozilla/layout/PRemotePrintJobParent.h"
#include "mozilla/media/PMediaParent.h"
#include "mozilla/net/PNeckoParent.h"
#include "mozilla/extensions/PStreamFilterParent.h"
#include "mozilla/gmp/PGMPContentParent.h"
#include "mozilla/gmp/PGMPServiceParent.h"
#include "mozilla/gmp/PGMPParent.h"
#include "mozilla/dom/PSpeechSynthesisParent.h"
#include "mozilla/ipc/PTestShellParent.h"
#include "mozilla/PRemoteSpellcheckEngineParent.h"
#include "mozilla/PWebBrowserPersistDocumentParent.h"
#include "mozilla/dom/PWebrtcGlobalParent.h"
#include "mozilla/dom/PWindowGlobalParent.h"
#include "mozilla/dom/PURLClassifierParent.h"
#include "mozilla/dom/PURLClassifierLocalParent.h"
#include "mozilla/gfx/PVRManagerParent.h"
#include "mozilla/PRemoteDecoderManagerParent.h"
#include "mozilla/dom/PRemoteWorkerServiceParent.h"
#include "mozilla/PProfilerParent.h"
#include "mozilla/loader/PScriptCacheParent.h"
#include "mozilla/dom/PSessionStorageObserverParent.h"
#include "mozilla/PBenchmarkStorageParent.h"
#include "mozilla/PSandboxTestingParent.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 PContentParent::RecvPExtensionsConstructor(PExtensionsParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPWebBrowserPersistDocumentConstructor(
PWebBrowserPersistDocumentParent* actor,
PBrowserParent* aBrowser,
const MaybeDiscardedBrowsingContext& aContext) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPRemoteSpellcheckEngineConstructor(PRemoteSpellcheckEngineParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPHalConstructor(PHalParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPHeapSnapshotTempFileHelperConstructor(PHeapSnapshotTempFileHelperParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPNeckoConstructor(PNeckoParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPSpeechSynthesisConstructor(PSpeechSynthesisParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPMediaConstructor(PMediaParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPWebrtcGlobalConstructor(PWebrtcGlobalParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPURLClassifierConstructor(
PURLClassifierParent* actor,
nsIPrincipal* principal,
bool* success) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPURLClassifierLocalConstructor(
PURLClassifierLocalParent* actor,
nsIURI* uri,
nsTArray<IPCURLClassifierFeature>&& features) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPSessionStorageObserverConstructor(PSessionStorageObserverParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPBenchmarkStorageConstructor(PBenchmarkStorageParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPExternalHelperAppConstructor(
PExternalHelperAppParent* actor,
nsIURI* uri,
const LoadInfoArgs& loadInfoArgs,
const nsACString& aMimeContentType,
const nsACString& aContentDisposition,
const uint32_t& aContentDispositionHint,
const nsAString& aContentDispositionFilename,
const bool& aForceSave,
const int64_t& aContentLength,
const bool& aWasFileChannel,
nsIURI* aReferrer,
const MaybeDiscardedBrowsingContext& aContext) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPHandlerServiceConstructor(PHandlerServiceParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPClipboardWriteRequestConstructor(
PClipboardWriteRequestParent* actor,
const ClipboardType& aClipboardType,
const MaybeDiscardedWindowContext& aSettingWindowContext) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::RecvPContentPermissionRequestConstructor(
PContentPermissionRequestParent* actor,
nsTArray<PermissionRequest>&& aRequests,
nsIPrincipal* aPrincipal,
nsIPrincipal* aTopLevelPrincipal,
const bool& aIsHandlingUserInput,
const bool& aMaybeUnsafePermissionDelegate,
const TabId& tabId) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PContentParent::ProcessingError(
Result aCode,
const char* aReason) -> void
{
}
auto PContentParent::ShouldContinueFromReplyTimeout() -> bool
{
return true;
}
MOZ_IMPLICIT PContentParent::PContentParent() :
mozilla::ipc::IToplevelProtocol("PContentParent", kProtocolId, mozilla::ipc::ParentSide)
{
MOZ_COUNT_CTOR(PContentParent);
}
PContentParent::~PContentParent()
{
MOZ_COUNT_DTOR(PContentParent);
}
auto PContentParent::ActorAlloc() -> void
{
MOZ_RELEASE_ASSERT(XRE_IsParentProcess(), "Invalid process for `PContentParent'");
AddRef();
}
auto PContentParent::ActorDealloc() -> void
{
Release();
}
auto PContentParent::OtherPid() const -> ::base::ProcessId
{
::base::ProcessId pid =
::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherPidMaybeInvalid();
MOZ_RELEASE_ASSERT(pid != ::base::kInvalidProcessId);
return pid;
}
auto PContentParent::OtherChildID() const -> ::GeckoChildID
{
::GeckoChildID childID =
::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherChildIDMaybeInvalid();
MOZ_RELEASE_ASSERT(childID != -1);
return childID;
}
auto PContentParent::OtherEndpointProcInfo() const -> ::mozilla::ipc::EndpointProcInfo
{
return ::mozilla::ipc::EndpointProcInfo{OtherPid(), OtherChildID()};
}
auto PContentParent::ManagedPBrowserParent(nsTArray<PBrowserParent*>& aArr) const -> void
{
mManagedPBrowserParent.ToArray(aArr);
}
auto PContentParent::ManagedPBrowserParent() const -> const ManagedContainer<PBrowserParent>&
{
return mManagedPBrowserParent;
}
auto PContentParent::ManagedPClipboardReadRequestParent(nsTArray<PClipboardReadRequestParent*>& aArr) const -> void
{
mManagedPClipboardReadRequestParent.ToArray(aArr);
}
auto PContentParent::ManagedPClipboardReadRequestParent() const -> const ManagedContainer<PClipboardReadRequestParent>&
{
return mManagedPClipboardReadRequestParent;
}
auto PContentParent::ManagedPClipboardWriteRequestParent(nsTArray<PClipboardWriteRequestParent*>& aArr) const -> void
{
mManagedPClipboardWriteRequestParent.ToArray(aArr);
}
auto PContentParent::ManagedPClipboardWriteRequestParent() const -> const ManagedContainer<PClipboardWriteRequestParent>&
{
return mManagedPClipboardWriteRequestParent;
}
auto PContentParent::ManagedPContentPermissionRequestParent(nsTArray<PContentPermissionRequestParent*>& aArr) const -> void
{
mManagedPContentPermissionRequestParent.ToArray(aArr);
}
auto PContentParent::ManagedPContentPermissionRequestParent() const -> const ManagedContainer<PContentPermissionRequestParent>&
{
return mManagedPContentPermissionRequestParent;
}
auto PContentParent::ManagedPCycleCollectWithLogsParent(nsTArray<PCycleCollectWithLogsParent*>& aArr) const -> void
{
mManagedPCycleCollectWithLogsParent.ToArray(aArr);
}
auto PContentParent::ManagedPCycleCollectWithLogsParent() const -> const ManagedContainer<PCycleCollectWithLogsParent>&
{
return mManagedPCycleCollectWithLogsParent;
}
auto PContentParent::ManagedPExtensionsParent(nsTArray<PExtensionsParent*>& aArr) const -> void
{
mManagedPExtensionsParent.ToArray(aArr);
}
auto PContentParent::ManagedPExtensionsParent() const -> const ManagedContainer<PExtensionsParent>&
{
return mManagedPExtensionsParent;
}
auto PContentParent::ManagedPExternalHelperAppParent(nsTArray<PExternalHelperAppParent*>& aArr) const -> void
{
mManagedPExternalHelperAppParent.ToArray(aArr);
}
auto PContentParent::ManagedPExternalHelperAppParent() const -> const ManagedContainer<PExternalHelperAppParent>&
{
return mManagedPExternalHelperAppParent;
}
auto PContentParent::ManagedPHalParent(nsTArray<PHalParent*>& aArr) const -> void
{
mManagedPHalParent.ToArray(aArr);
}
auto PContentParent::ManagedPHalParent() const -> const ManagedContainer<PHalParent>&
{
return mManagedPHalParent;
}
auto PContentParent::ManagedPHandlerServiceParent(nsTArray<PHandlerServiceParent*>& aArr) const -> void
{
mManagedPHandlerServiceParent.ToArray(aArr);
}
auto PContentParent::ManagedPHandlerServiceParent() const -> const ManagedContainer<PHandlerServiceParent>&
{
return mManagedPHandlerServiceParent;
}
auto PContentParent::ManagedPHeapSnapshotTempFileHelperParent(nsTArray<PHeapSnapshotTempFileHelperParent*>& aArr) const -> void
{
mManagedPHeapSnapshotTempFileHelperParent.ToArray(aArr);
}
auto PContentParent::ManagedPHeapSnapshotTempFileHelperParent() const -> const ManagedContainer<PHeapSnapshotTempFileHelperParent>&
{
return mManagedPHeapSnapshotTempFileHelperParent;
}
auto PContentParent::ManagedPRemotePrintJobParent(nsTArray<PRemotePrintJobParent*>& aArr) const -> void
{
mManagedPRemotePrintJobParent.ToArray(aArr);
}
auto PContentParent::ManagedPRemotePrintJobParent() const -> const ManagedContainer<PRemotePrintJobParent>&
{
return mManagedPRemotePrintJobParent;
}
auto PContentParent::ManagedPMediaParent(nsTArray<PMediaParent*>& aArr) const -> void
{
mManagedPMediaParent.ToArray(aArr);
}
auto PContentParent::ManagedPMediaParent() const -> const ManagedContainer<PMediaParent>&
{
return mManagedPMediaParent;
}
auto PContentParent::ManagedPNeckoParent(nsTArray<PNeckoParent*>& aArr) const -> void
{
mManagedPNeckoParent.ToArray(aArr);
}
auto PContentParent::ManagedPNeckoParent() const -> const ManagedContainer<PNeckoParent>&
{
return mManagedPNeckoParent;
}
auto PContentParent::ManagedPSpeechSynthesisParent(nsTArray<PSpeechSynthesisParent*>& aArr) const -> void
{
mManagedPSpeechSynthesisParent.ToArray(aArr);
}
auto PContentParent::ManagedPSpeechSynthesisParent() const -> const ManagedContainer<PSpeechSynthesisParent>&
{
return mManagedPSpeechSynthesisParent;
}
auto PContentParent::ManagedPTestShellParent(nsTArray<PTestShellParent*>& aArr) const -> void
{
mManagedPTestShellParent.ToArray(aArr);
}
auto PContentParent::ManagedPTestShellParent() const -> const ManagedContainer<PTestShellParent>&
{
return mManagedPTestShellParent;
}
auto PContentParent::ManagedPRemoteSpellcheckEngineParent(nsTArray<PRemoteSpellcheckEngineParent*>& aArr) const -> void
{
mManagedPRemoteSpellcheckEngineParent.ToArray(aArr);
}
auto PContentParent::ManagedPRemoteSpellcheckEngineParent() const -> const ManagedContainer<PRemoteSpellcheckEngineParent>&
{
return mManagedPRemoteSpellcheckEngineParent;
}
auto PContentParent::ManagedPWebBrowserPersistDocumentParent(nsTArray<PWebBrowserPersistDocumentParent*>& aArr) const -> void
{
mManagedPWebBrowserPersistDocumentParent.ToArray(aArr);
}
auto PContentParent::ManagedPWebBrowserPersistDocumentParent() const -> const ManagedContainer<PWebBrowserPersistDocumentParent>&
{
return mManagedPWebBrowserPersistDocumentParent;
}
auto PContentParent::ManagedPWebrtcGlobalParent(nsTArray<PWebrtcGlobalParent*>& aArr) const -> void
{
mManagedPWebrtcGlobalParent.ToArray(aArr);
}
auto PContentParent::ManagedPWebrtcGlobalParent() const -> const ManagedContainer<PWebrtcGlobalParent>&
{
return mManagedPWebrtcGlobalParent;
}
auto PContentParent::ManagedPURLClassifierParent(nsTArray<PURLClassifierParent*>& aArr) const -> void
{
mManagedPURLClassifierParent.ToArray(aArr);
}
auto PContentParent::ManagedPURLClassifierParent() const -> const ManagedContainer<PURLClassifierParent>&
{
return mManagedPURLClassifierParent;
}
auto PContentParent::ManagedPURLClassifierLocalParent(nsTArray<PURLClassifierLocalParent*>& aArr) const -> void
{
mManagedPURLClassifierLocalParent.ToArray(aArr);
}
auto PContentParent::ManagedPURLClassifierLocalParent() const -> const ManagedContainer<PURLClassifierLocalParent>&
{
return mManagedPURLClassifierLocalParent;
}
auto PContentParent::ManagedPScriptCacheParent(nsTArray<PScriptCacheParent*>& aArr) const -> void
{
mManagedPScriptCacheParent.ToArray(aArr);
}
auto PContentParent::ManagedPScriptCacheParent() const -> const ManagedContainer<PScriptCacheParent>&
{
return mManagedPScriptCacheParent;
}
auto PContentParent::ManagedPSessionStorageObserverParent(nsTArray<PSessionStorageObserverParent*>& aArr) const -> void
{
mManagedPSessionStorageObserverParent.ToArray(aArr);
}
auto PContentParent::ManagedPSessionStorageObserverParent() const -> const ManagedContainer<PSessionStorageObserverParent>&
{
return mManagedPSessionStorageObserverParent;
}
auto PContentParent::ManagedPBenchmarkStorageParent(nsTArray<PBenchmarkStorageParent*>& aArr) const -> void
{
mManagedPBenchmarkStorageParent.ToArray(aArr);
}
auto PContentParent::ManagedPBenchmarkStorageParent() const -> const ManagedContainer<PBenchmarkStorageParent>&
{
return mManagedPBenchmarkStorageParent;
}
auto PContentParent::ManagedProtocolIds() const -> mozilla::Span<mozilla::ipc::ProtocolId const>
{
static constexpr ::mozilla::ipc::ProtocolId sIds[] = {
PBrowserMsgStart,
PClipboardReadRequestMsgStart,
PClipboardWriteRequestMsgStart,
PContentPermissionRequestMsgStart,
PCycleCollectWithLogsMsgStart,
PExtensionsMsgStart,
PExternalHelperAppMsgStart,
PHalMsgStart,
PHandlerServiceMsgStart,
PHeapSnapshotTempFileHelperMsgStart,
PRemotePrintJobMsgStart,
PMediaMsgStart,
PNeckoMsgStart,
PSpeechSynthesisMsgStart,
PTestShellMsgStart,
PRemoteSpellcheckEngineMsgStart,
PWebBrowserPersistDocumentMsgStart,
PWebrtcGlobalMsgStart,
PURLClassifierMsgStart,
PURLClassifierLocalMsgStart,
PScriptCacheMsgStart,
PSessionStorageObserverMsgStart,
PBenchmarkStorageMsgStart
};
return sIds;
}
auto PContentParent::GetManagedActors(mozilla::ipc::ProtocolId aProtocol) -> UntypedManagedContainer*
{
switch (aProtocol) {
case PBrowserMsgStart:
return (&(mManagedPBrowserParent));
case PClipboardReadRequestMsgStart:
return (&(mManagedPClipboardReadRequestParent));
case PClipboardWriteRequestMsgStart:
return (&(mManagedPClipboardWriteRequestParent));
case PContentPermissionRequestMsgStart:
return (&(mManagedPContentPermissionRequestParent));
case PCycleCollectWithLogsMsgStart:
return (&(mManagedPCycleCollectWithLogsParent));
case PExtensionsMsgStart:
return (&(mManagedPExtensionsParent));
case PExternalHelperAppMsgStart:
return (&(mManagedPExternalHelperAppParent));
case PHalMsgStart:
return (&(mManagedPHalParent));
case PHandlerServiceMsgStart:
return (&(mManagedPHandlerServiceParent));
case PHeapSnapshotTempFileHelperMsgStart:
return (&(mManagedPHeapSnapshotTempFileHelperParent));
case PRemotePrintJobMsgStart:
return (&(mManagedPRemotePrintJobParent));
case PMediaMsgStart:
return (&(mManagedPMediaParent));
case PNeckoMsgStart:
return (&(mManagedPNeckoParent));
case PSpeechSynthesisMsgStart:
return (&(mManagedPSpeechSynthesisParent));
case PTestShellMsgStart:
return (&(mManagedPTestShellParent));
case PRemoteSpellcheckEngineMsgStart:
return (&(mManagedPRemoteSpellcheckEngineParent));
case PWebBrowserPersistDocumentMsgStart:
return (&(mManagedPWebBrowserPersistDocumentParent));
case PWebrtcGlobalMsgStart:
return (&(mManagedPWebrtcGlobalParent));
case PURLClassifierMsgStart:
return (&(mManagedPURLClassifierParent));
case PURLClassifierLocalMsgStart:
return (&(mManagedPURLClassifierLocalParent));
case PScriptCacheMsgStart:
return (&(mManagedPScriptCacheParent));
case PSessionStorageObserverMsgStart:
return (&(mManagedPSessionStorageObserverParent));
case PBenchmarkStorageMsgStart:
return (&(mManagedPBenchmarkStorageParent));
default:
return nullptr;
}
}
auto PContentParent::OpenPBrowserEndpoint(PBrowserParent* aActor) -> ManagedEndpoint<PBrowserChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBrowserParent actor");
return ManagedEndpoint<PBrowserChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PBrowserParent actor");
return ManagedEndpoint<PBrowserChild>();
}
// 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<PBrowserChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPBrowserEndpoint(
ManagedEndpoint<PBrowserParent> aEndpoint,
PBrowserParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPClipboardReadRequestEndpoint(PClipboardReadRequestParent* aActor) -> ManagedEndpoint<PClipboardReadRequestChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PClipboardReadRequestParent actor");
return ManagedEndpoint<PClipboardReadRequestChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PClipboardReadRequestParent actor");
return ManagedEndpoint<PClipboardReadRequestChild>();
}
// 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<PClipboardReadRequestChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPClipboardReadRequestEndpoint(
ManagedEndpoint<PClipboardReadRequestParent> aEndpoint,
PClipboardReadRequestParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPClipboardWriteRequestEndpoint(PClipboardWriteRequestParent* aActor) -> ManagedEndpoint<PClipboardWriteRequestChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PClipboardWriteRequestParent actor");
return ManagedEndpoint<PClipboardWriteRequestChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PClipboardWriteRequestParent actor");
return ManagedEndpoint<PClipboardWriteRequestChild>();
}
// 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<PClipboardWriteRequestChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPClipboardWriteRequestEndpoint(
ManagedEndpoint<PClipboardWriteRequestParent> aEndpoint,
PClipboardWriteRequestParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPContentPermissionRequestEndpoint(PContentPermissionRequestParent* aActor) -> ManagedEndpoint<PContentPermissionRequestChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PContentPermissionRequestParent actor");
return ManagedEndpoint<PContentPermissionRequestChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PContentPermissionRequestParent actor");
return ManagedEndpoint<PContentPermissionRequestChild>();
}
// 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<PContentPermissionRequestChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPContentPermissionRequestEndpoint(
ManagedEndpoint<PContentPermissionRequestParent> aEndpoint,
PContentPermissionRequestParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPCycleCollectWithLogsEndpoint(PCycleCollectWithLogsParent* aActor) -> ManagedEndpoint<PCycleCollectWithLogsChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PCycleCollectWithLogsParent actor");
return ManagedEndpoint<PCycleCollectWithLogsChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PCycleCollectWithLogsParent actor");
return ManagedEndpoint<PCycleCollectWithLogsChild>();
}
// 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<PCycleCollectWithLogsChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPCycleCollectWithLogsEndpoint(
ManagedEndpoint<PCycleCollectWithLogsParent> aEndpoint,
PCycleCollectWithLogsParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPExtensionsEndpoint(PExtensionsParent* aActor) -> ManagedEndpoint<PExtensionsChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PExtensionsParent actor");
return ManagedEndpoint<PExtensionsChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PExtensionsParent actor");
return ManagedEndpoint<PExtensionsChild>();
}
// 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<PExtensionsChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPExtensionsEndpoint(
ManagedEndpoint<PExtensionsParent> aEndpoint,
PExtensionsParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPExternalHelperAppEndpoint(PExternalHelperAppParent* aActor) -> ManagedEndpoint<PExternalHelperAppChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PExternalHelperAppParent actor");
return ManagedEndpoint<PExternalHelperAppChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PExternalHelperAppParent actor");
return ManagedEndpoint<PExternalHelperAppChild>();
}
// 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<PExternalHelperAppChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPExternalHelperAppEndpoint(
ManagedEndpoint<PExternalHelperAppParent> aEndpoint,
PExternalHelperAppParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPHalEndpoint(PHalParent* aActor) -> ManagedEndpoint<PHalChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PHalParent actor");
return ManagedEndpoint<PHalChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PHalParent actor");
return ManagedEndpoint<PHalChild>();
}
// 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<PHalChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPHalEndpoint(
ManagedEndpoint<PHalParent> aEndpoint,
PHalParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPHandlerServiceEndpoint(PHandlerServiceParent* aActor) -> ManagedEndpoint<PHandlerServiceChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PHandlerServiceParent actor");
return ManagedEndpoint<PHandlerServiceChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PHandlerServiceParent actor");
return ManagedEndpoint<PHandlerServiceChild>();
}
// 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<PHandlerServiceChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPHandlerServiceEndpoint(
ManagedEndpoint<PHandlerServiceParent> aEndpoint,
PHandlerServiceParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPHeapSnapshotTempFileHelperEndpoint(PHeapSnapshotTempFileHelperParent* aActor) -> ManagedEndpoint<PHeapSnapshotTempFileHelperChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PHeapSnapshotTempFileHelperParent actor");
return ManagedEndpoint<PHeapSnapshotTempFileHelperChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PHeapSnapshotTempFileHelperParent actor");
return ManagedEndpoint<PHeapSnapshotTempFileHelperChild>();
}
// 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<PHeapSnapshotTempFileHelperChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPHeapSnapshotTempFileHelperEndpoint(
ManagedEndpoint<PHeapSnapshotTempFileHelperParent> aEndpoint,
PHeapSnapshotTempFileHelperParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPRemotePrintJobEndpoint(PRemotePrintJobParent* aActor) -> ManagedEndpoint<PRemotePrintJobChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PRemotePrintJobParent actor");
return ManagedEndpoint<PRemotePrintJobChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PRemotePrintJobParent actor");
return ManagedEndpoint<PRemotePrintJobChild>();
}
// 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<PRemotePrintJobChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPRemotePrintJobEndpoint(
ManagedEndpoint<PRemotePrintJobParent> aEndpoint,
PRemotePrintJobParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPMediaEndpoint(PMediaParent* aActor) -> ManagedEndpoint<PMediaChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PMediaParent actor");
return ManagedEndpoint<PMediaChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PMediaParent actor");
return ManagedEndpoint<PMediaChild>();
}
// 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<PMediaChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPMediaEndpoint(
ManagedEndpoint<PMediaParent> aEndpoint,
PMediaParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPNeckoEndpoint(PNeckoParent* aActor) -> ManagedEndpoint<PNeckoChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PNeckoParent actor");
return ManagedEndpoint<PNeckoChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PNeckoParent actor");
return ManagedEndpoint<PNeckoChild>();
}
// 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<PNeckoChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPNeckoEndpoint(
ManagedEndpoint<PNeckoParent> aEndpoint,
PNeckoParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPSpeechSynthesisEndpoint(PSpeechSynthesisParent* aActor) -> ManagedEndpoint<PSpeechSynthesisChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PSpeechSynthesisParent actor");
return ManagedEndpoint<PSpeechSynthesisChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PSpeechSynthesisParent actor");
return ManagedEndpoint<PSpeechSynthesisChild>();
}
// 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<PSpeechSynthesisChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPSpeechSynthesisEndpoint(
ManagedEndpoint<PSpeechSynthesisParent> aEndpoint,
PSpeechSynthesisParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPTestShellEndpoint(PTestShellParent* aActor) -> ManagedEndpoint<PTestShellChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PTestShellParent actor");
return ManagedEndpoint<PTestShellChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PTestShellParent actor");
return ManagedEndpoint<PTestShellChild>();
}
// 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<PTestShellChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPTestShellEndpoint(
ManagedEndpoint<PTestShellParent> aEndpoint,
PTestShellParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPRemoteSpellcheckEngineEndpoint(PRemoteSpellcheckEngineParent* aActor) -> ManagedEndpoint<PRemoteSpellcheckEngineChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PRemoteSpellcheckEngineParent actor");
return ManagedEndpoint<PRemoteSpellcheckEngineChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PRemoteSpellcheckEngineParent actor");
return ManagedEndpoint<PRemoteSpellcheckEngineChild>();
}
// 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<PRemoteSpellcheckEngineChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPRemoteSpellcheckEngineEndpoint(
ManagedEndpoint<PRemoteSpellcheckEngineParent> aEndpoint,
PRemoteSpellcheckEngineParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPWebBrowserPersistDocumentEndpoint(PWebBrowserPersistDocumentParent* aActor) -> ManagedEndpoint<PWebBrowserPersistDocumentChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWebBrowserPersistDocumentParent actor");
return ManagedEndpoint<PWebBrowserPersistDocumentChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PWebBrowserPersistDocumentParent actor");
return ManagedEndpoint<PWebBrowserPersistDocumentChild>();
}
// 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<PWebBrowserPersistDocumentChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPWebBrowserPersistDocumentEndpoint(
ManagedEndpoint<PWebBrowserPersistDocumentParent> aEndpoint,
PWebBrowserPersistDocumentParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPWebrtcGlobalEndpoint(PWebrtcGlobalParent* aActor) -> ManagedEndpoint<PWebrtcGlobalChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWebrtcGlobalParent actor");
return ManagedEndpoint<PWebrtcGlobalChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PWebrtcGlobalParent actor");
return ManagedEndpoint<PWebrtcGlobalChild>();
}
// 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<PWebrtcGlobalChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPWebrtcGlobalEndpoint(
ManagedEndpoint<PWebrtcGlobalParent> aEndpoint,
PWebrtcGlobalParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPURLClassifierEndpoint(PURLClassifierParent* aActor) -> ManagedEndpoint<PURLClassifierChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PURLClassifierParent actor");
return ManagedEndpoint<PURLClassifierChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PURLClassifierParent actor");
return ManagedEndpoint<PURLClassifierChild>();
}
// 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<PURLClassifierChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPURLClassifierEndpoint(
ManagedEndpoint<PURLClassifierParent> aEndpoint,
PURLClassifierParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPURLClassifierLocalEndpoint(PURLClassifierLocalParent* aActor) -> ManagedEndpoint<PURLClassifierLocalChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PURLClassifierLocalParent actor");
return ManagedEndpoint<PURLClassifierLocalChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PURLClassifierLocalParent actor");
return ManagedEndpoint<PURLClassifierLocalChild>();
}
// 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<PURLClassifierLocalChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPURLClassifierLocalEndpoint(
ManagedEndpoint<PURLClassifierLocalParent> aEndpoint,
PURLClassifierLocalParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPScriptCacheEndpoint(PScriptCacheParent* aActor) -> ManagedEndpoint<PScriptCacheChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PScriptCacheParent actor");
return ManagedEndpoint<PScriptCacheChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PScriptCacheParent actor");
return ManagedEndpoint<PScriptCacheChild>();
}
// 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<PScriptCacheChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPScriptCacheEndpoint(
ManagedEndpoint<PScriptCacheParent> aEndpoint,
PScriptCacheParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPSessionStorageObserverEndpoint(PSessionStorageObserverParent* aActor) -> ManagedEndpoint<PSessionStorageObserverChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PSessionStorageObserverParent actor");
return ManagedEndpoint<PSessionStorageObserverChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PSessionStorageObserverParent actor");
return ManagedEndpoint<PSessionStorageObserverChild>();
}
// 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<PSessionStorageObserverChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPSessionStorageObserverEndpoint(
ManagedEndpoint<PSessionStorageObserverParent> aEndpoint,
PSessionStorageObserverParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::OpenPBenchmarkStorageEndpoint(PBenchmarkStorageParent* aActor) -> ManagedEndpoint<PBenchmarkStorageChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBenchmarkStorageParent actor");
return ManagedEndpoint<PBenchmarkStorageChild>();
}
if (!aActor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PBenchmarkStorageParent actor");
return ManagedEndpoint<PBenchmarkStorageChild>();
}
// 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<PBenchmarkStorageChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PContentParent::BindPBenchmarkStorageEndpoint(
ManagedEndpoint<PBenchmarkStorageParent> aEndpoint,
PBenchmarkStorageParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}
auto PContentParent::SendConstructBrowser(
ManagedEndpoint<::mozilla::dom::PBrowserChild>&& browserEp,
ManagedEndpoint<::mozilla::dom::PWindowGlobalChild>&& windowEp,
const TabId& tabId,
const IPCTabContext& context,
const WindowGlobalInit& windowInit,
const uint32_t& chromeFlags,
const ContentParentId& cpId,
const bool& isForBrowser,
const bool& isTopLevel) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ConstructBrowser(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);
IPC::WriteParam((&(writer__)), cpId);
// Sentinel = 'cpId'
((&(writer__)))->WriteSentinel(64356737);
IPC::WriteParam((&(writer__)), isForBrowser);
// Sentinel = 'isForBrowser'
((&(writer__)))->WriteSentinel(523371752);
IPC::WriteParam((&(writer__)), isTopLevel);
// Sentinel = 'isTopLevel'
((&(writer__)))->WriteSentinel(371196936);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ConstructBrowser", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendPWebBrowserPersistDocumentConstructor(
PWebBrowserPersistDocumentParent* actor,
PBrowserParent* aBrowser,
const MaybeDiscardedBrowsingContext& aContext) -> PWebBrowserPersistDocumentParent*
{
if (!actor) {
NS_WARNING("Cannot bind null PWebBrowserPersistDocumentParent actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PWebBrowserPersistDocumentParent actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PWebBrowserPersistDocumentConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), aBrowser);
// Sentinel = 'aBrowser'
((&(writer__)))->WriteSentinel(237372230);
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PWebBrowserPersistDocumentParent constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentParent::SendRawMessage(
const JSActorMessageMeta& aMetadata,
const mozilla::Maybe<ClonedMessageData>& aData,
const mozilla::Maybe<ClonedMessageData>& aStack) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RawMessage(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aMetadata);
// Sentinel = 'aMetadata'
((&(writer__)))->WriteSentinel(288752515);
IPC::WriteParam((&(writer__)), aData);
// Sentinel = 'aData'
((&(writer__)))->WriteSentinel(90571228);
IPC::WriteParam((&(writer__)), aStack);
// Sentinel = 'aStack'
((&(writer__)))->WriteSentinel(135201368);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendInitGMPService(Endpoint<::mozilla::gmp::PGMPServiceChild>&& service) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InitGMPService(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), std::move(service));
// Sentinel = 'service'
((&(writer__)))->WriteSentinel(201458418);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitGMPService", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendInitProcessHangMonitor(Endpoint<::mozilla::PProcessHangMonitorChild>&& hangMonitor) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InitProcessHangMonitor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), std::move(hangMonitor));
// Sentinel = 'hangMonitor'
((&(writer__)))->WriteSentinel(445514887);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitProcessHangMonitor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendInitProfiler(Endpoint<::mozilla::PProfilerChild>&& aEndpoint) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InitProfiler(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitProfiler", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendInitRendering(
Endpoint<::mozilla::layers::PCompositorManagerChild>&& compositor,
Endpoint<::mozilla::layers::PImageBridgeChild>&& imageBridge,
Endpoint<::mozilla::gfx::PVRManagerChild>&& vr,
Endpoint<::mozilla::PRemoteDecoderManagerChild>&& video,
mozilla::Span<uint32_t const> namespaces) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InitRendering(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), std::move(compositor));
// Sentinel = 'compositor'
((&(writer__)))->WriteSentinel(393217104);
IPC::WriteParam((&(writer__)), std::move(imageBridge));
// Sentinel = 'imageBridge'
((&(writer__)))->WriteSentinel(436012113);
IPC::WriteParam((&(writer__)), std::move(vr));
// Sentinel = 'vr'
((&(writer__)))->WriteSentinel(23068905);
IPC::WriteParam((&(writer__)), std::move(video));
// Sentinel = 'video'
((&(writer__)))->WriteSentinel(106693144);
IPC::WriteParam((&(writer__)), namespaces);
// Sentinel = 'namespaces'
((&(writer__)))->WriteSentinel(381027361);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitRendering", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendReinitRendering(
Endpoint<::mozilla::layers::PCompositorManagerChild>&& compositor,
Endpoint<::mozilla::layers::PImageBridgeChild>&& bridge,
Endpoint<::mozilla::gfx::PVRManagerChild>&& vr,
Endpoint<::mozilla::PRemoteDecoderManagerChild>&& video,
mozilla::Span<uint32_t const> namespaces) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ReinitRendering(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), std::move(compositor));
// Sentinel = 'compositor'
((&(writer__)))->WriteSentinel(393217104);
IPC::WriteParam((&(writer__)), std::move(bridge));
// Sentinel = 'bridge'
((&(writer__)))->WriteSentinel(143589998);
IPC::WriteParam((&(writer__)), std::move(vr));
// Sentinel = 'vr'
((&(writer__)))->WriteSentinel(23068905);
IPC::WriteParam((&(writer__)), std::move(video));
// Sentinel = 'video'
((&(writer__)))->WriteSentinel(106693144);
IPC::WriteParam((&(writer__)), namespaces);
// Sentinel = 'namespaces'
((&(writer__)))->WriteSentinel(381027361);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReinitRendering", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendNetworkLinkTypeChange(const uint32_t& type) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NetworkLinkTypeChange(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), type);
// Sentinel = 'type'
((&(writer__)))->WriteSentinel(75760067);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NetworkLinkTypeChange", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendSocketProcessCrashed() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SocketProcessCrashed(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SocketProcessCrashed", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendReinitRenderingForDeviceReset() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ReinitRenderingForDeviceReset(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReinitRenderingForDeviceReset", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendSetProcessSandbox(const mozilla::Maybe<FileDescriptor>& aBroker) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetProcessSandbox(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aBroker);
// Sentinel = 'aBroker'
((&(writer__)))->WriteSentinel(179110599);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetProcessSandbox", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendRequestMemoryReport(
const uint32_t& generation,
const bool& anonymize,
const bool& minimizeMemoryUsage,
const mozilla::Maybe<FileDescriptor>& DMDFile,
mozilla::ipc::ResolveCallback<uint32_t>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RequestMemoryReport(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), generation);
// Sentinel = 'generation'
((&(writer__)))->WriteSentinel(381158445);
IPC::WriteParam((&(writer__)), anonymize);
// Sentinel = 'anonymize'
((&(writer__)))->WriteSentinel(321127387);
IPC::WriteParam((&(writer__)), minimizeMemoryUsage);
// Sentinel = 'minimizeMemoryUsage'
((&(writer__)))->WriteSentinel(1321600977);
IPC::WriteParam((&(writer__)), DMDFile);
// Sentinel = 'DMDFile'
((&(writer__)))->WriteSentinel(143983190);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RequestMemoryReport", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_RequestMemoryReport__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentParent::SendRequestMemoryReport(
const uint32_t& generation,
const bool& anonymize,
const bool& minimizeMemoryUsage,
const mozilla::Maybe<FileDescriptor>& DMDFile) -> RefPtr<RequestMemoryReportPromise>
{
RefPtr<MozPromise<uint32_t, ResponseRejectReason, true>::Private> promise__ = new MozPromise<uint32_t, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendRequestMemoryReport(std::move(generation), std::move(anonymize), std::move(minimizeMemoryUsage), std::move(DMDFile), [promise__](uint32_t&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentParent::SendBidiKeyboardNotify(
const bool& isLangRTL,
const bool& haveBidiKeyboards) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_BidiKeyboardNotify(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), isLangRTL);
// Sentinel = 'isLangRTL'
((&(writer__)))->WriteSentinel(290980689);
IPC::WriteParam((&(writer__)), haveBidiKeyboards);
// Sentinel = 'haveBidiKeyboards'
((&(writer__)))->WriteSentinel(1003161281);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_BidiKeyboardNotify", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendPCycleCollectWithLogsConstructor(
const bool& dumpAllTraces,
const FileDescriptor& gcLog,
const FileDescriptor& ccLog) -> PCycleCollectWithLogsParent*
{
PCycleCollectWithLogsParent* actor = (static_cast<ContentParent*>(this))->AllocPCycleCollectWithLogsParent(dumpAllTraces, gcLog, ccLog);
return SendPCycleCollectWithLogsConstructor(std::move(actor), std::move(dumpAllTraces), std::move(gcLog), std::move(ccLog));
}
auto PContentParent::SendPCycleCollectWithLogsConstructor(
PCycleCollectWithLogsParent* actor,
const bool& dumpAllTraces,
const FileDescriptor& gcLog,
const FileDescriptor& ccLog) -> PCycleCollectWithLogsParent*
{
if (!actor) {
NS_WARNING("Cannot bind null PCycleCollectWithLogsParent actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PCycleCollectWithLogsParent actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PCycleCollectWithLogsConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), dumpAllTraces);
// Sentinel = 'dumpAllTraces'
((&(writer__)))->WriteSentinel(610600242);
IPC::WriteParam((&(writer__)), gcLog);
// Sentinel = 'gcLog'
((&(writer__)))->WriteSentinel(96272877);
IPC::WriteParam((&(writer__)), ccLog);
// Sentinel = 'ccLog'
((&(writer__)))->WriteSentinel(94962153);
// 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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PCycleCollectWithLogsConstructor", 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 PCycleCollectWithLogsParent constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentParent::SendPTestShellConstructor(PTestShellParent* actor) -> PTestShellParent*
{
if (!actor) {
NS_WARNING("Cannot bind null PTestShellParent actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PTestShellParent actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PTestShellConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PTestShellConstructor", 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 PTestShellParent constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentParent::SendPScriptCacheConstructor(
const FileDescOrError& cacheFile,
const bool& wantCacheData) -> PScriptCacheParent*
{
PScriptCacheParent* actor = (static_cast<ContentParent*>(this))->AllocPScriptCacheParent(cacheFile, wantCacheData);
return SendPScriptCacheConstructor(std::move(actor), std::move(cacheFile), std::move(wantCacheData));
}
auto PContentParent::SendPScriptCacheConstructor(
PScriptCacheParent* actor,
const FileDescOrError& cacheFile,
const bool& wantCacheData) -> PScriptCacheParent*
{
if (!actor) {
NS_WARNING("Cannot bind null PScriptCacheParent actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PScriptCacheParent actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PScriptCacheConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), cacheFile);
// Sentinel = 'cacheFile'
((&(writer__)))->WriteSentinel(289014645);
IPC::WriteParam((&(writer__)), wantCacheData);
// Sentinel = 'wantCacheData'
((&(writer__)))->WriteSentinel(602080521);
// 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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PScriptCacheConstructor", 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 PScriptCacheParent constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentParent::SendRegisterChrome(
mozilla::Span<ChromePackage const> packages,
mozilla::Span<SubstitutionMapping const> substitutions,
mozilla::Span<OverrideMapping const> overrides,
const nsACString& locale,
const bool& reset) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RegisterChrome(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), packages);
// Sentinel = 'packages'
((&(writer__)))->WriteSentinel(244187968);
IPC::WriteParam((&(writer__)), substitutions);
// Sentinel = 'substitutions'
((&(writer__)))->WriteSentinel(668861873);
IPC::WriteParam((&(writer__)), overrides);
// Sentinel = 'overrides'
((&(writer__)))->WriteSentinel(324404180);
IPC::WriteParam((&(writer__)), locale);
// Sentinel = 'locale'
((&(writer__)))->WriteSentinel(145031793);
IPC::WriteParam((&(writer__)), reset);
// Sentinel = 'reset'
((&(writer__)))->WriteSentinel(107610660);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RegisterChrome", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendRegisterChromeItem(const ChromeRegistryItem& item) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RegisterChromeItem(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), item);
// Sentinel = 'item'
((&(writer__)))->WriteSentinel(70975920);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RegisterChromeItem", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendClearImageCacheFromPrincipal(nsIPrincipal* aPrincipal) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ClearImageCacheFromPrincipal(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPrincipal);
// Sentinel = 'aPrincipal'
((&(writer__)))->WriteSentinel(364381188);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClearImageCacheFromPrincipal", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendClearImageCacheFromBaseDomain(const nsACString& aBaseDomain) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ClearImageCacheFromBaseDomain(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aBaseDomain);
// Sentinel = 'aBaseDomain'
((&(writer__)))->WriteSentinel(409470005);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClearImageCacheFromBaseDomain", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendClearImageCache(
const bool& privateLoader,
const bool& chrome) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ClearImageCache(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), privateLoader);
// Sentinel = 'privateLoader'
((&(writer__)))->WriteSentinel(635372883);
IPC::WriteParam((&(writer__)), chrome);
// Sentinel = 'chrome'
((&(writer__)))->WriteSentinel(146014847);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClearImageCache", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendClearStyleSheetCache(
const mozilla::Maybe<RefPtr<nsIPrincipal>>& aForPrincipal,
const mozilla::Maybe<nsCString>& aBaseDomain) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ClearStyleSheetCache(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aForPrincipal);
// Sentinel = 'aForPrincipal'
((&(writer__)))->WriteSentinel(593429803);
IPC::WriteParam((&(writer__)), aBaseDomain);
// Sentinel = 'aBaseDomain'
((&(writer__)))->WriteSentinel(409470005);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClearStyleSheetCache", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendClearScriptCache(
const mozilla::Maybe<RefPtr<nsIPrincipal>>& aForPrincipal,
const mozilla::Maybe<nsCString>& aBaseDomain) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ClearScriptCache(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aForPrincipal);
// Sentinel = 'aForPrincipal'
((&(writer__)))->WriteSentinel(593429803);
IPC::WriteParam((&(writer__)), aBaseDomain);
// Sentinel = 'aBaseDomain'
((&(writer__)))->WriteSentinel(409470005);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClearScriptCache", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendSetOffline(const bool& offline) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetOffline(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), offline);
// Sentinel = 'offline'
((&(writer__)))->WriteSentinel(194904804);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetOffline", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendSetConnectivity(const bool& connectivity) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetConnectivity(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), connectivity);
// Sentinel = 'connectivity'
((&(writer__)))->WriteSentinel(548734240);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetConnectivity", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendSetCaptivePortalState(const int32_t& aState) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetCaptivePortalState(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aState);
// Sentinel = 'aState'
((&(writer__)))->WriteSentinel(137036387);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetCaptivePortalState", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendSetTRRMode(
const ResolverMode& aMode,
const ResolverMode& aModeFromPref) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetTRRMode(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aMode);
// Sentinel = 'aMode'
((&(writer__)))->WriteSentinel(93848039);
IPC::WriteParam((&(writer__)), aModeFromPref);
// Sentinel = 'aModeFromPref'
((&(writer__)))->WriteSentinel(580846856);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetTRRMode", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendNotifyVisited(mozilla::Span<VisitedQueryResult const> uri) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyVisited(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), uri);
// Sentinel = 'uri'
((&(writer__)))->WriteSentinel(45023569);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyVisited", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendThemeChanged(
const FullLookAndFeel& lookAndFeelData,
const ThemeChangeKind& aKind) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ThemeChanged(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), lookAndFeelData);
// Sentinel = 'lookAndFeelData'
((&(writer__)))->WriteSentinel(782239167);
IPC::WriteParam((&(writer__)), aKind);
// Sentinel = 'aKind'
((&(writer__)))->WriteSentinel(93389288);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ThemeChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendPreferenceUpdate(const Pref& pref) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_PreferenceUpdate(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), pref);
// Sentinel = 'pref'
((&(writer__)))->WriteSentinel(71958958);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PreferenceUpdate", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendVarUpdate(const GfxVarUpdate& var) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_VarUpdate(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), var);
// Sentinel = 'var'
((&(writer__)))->WriteSentinel(43581770);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_VarUpdate", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendUpdatePerfStatsCollectionMask(const uint64_t& aMask) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdatePerfStatsCollectionMask(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aMask);
// Sentinel = 'aMask'
((&(writer__)))->WriteSentinel(93454830);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdatePerfStatsCollectionMask", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendCollectPerfStatsJSON(
mozilla::ipc::ResolveCallback<nsCString>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CollectPerfStatsJSON(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CollectPerfStatsJSON", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_CollectPerfStatsJSON__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentParent::SendCollectPerfStatsJSON() -> RefPtr<CollectPerfStatsJSONPromise>
{
RefPtr<MozPromise<nsCString, ResponseRejectReason, true>::Private> promise__ = new MozPromise<nsCString, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendCollectPerfStatsJSON([promise__](nsCString&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentParent::SendCollectScrollingMetrics(
mozilla::ipc::ResolveCallback<std::tuple<uint32_t, uint32_t>>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CollectScrollingMetrics(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CollectScrollingMetrics", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_CollectScrollingMetrics__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentParent::SendCollectScrollingMetrics() -> RefPtr<CollectScrollingMetricsPromise>
{
RefPtr<MozPromise<std::tuple<uint32_t, uint32_t>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<std::tuple<uint32_t, uint32_t>, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendCollectScrollingMetrics([promise__](std::tuple<uint32_t, uint32_t>&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentParent::SendNotifyAlertsObserver(
const nsACString& topic,
const nsAString& data) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyAlertsObserver(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), topic);
// Sentinel = 'topic'
((&(writer__)))->WriteSentinel(109707808);
IPC::WriteParam((&(writer__)), data);
// Sentinel = 'data'
((&(writer__)))->WriteSentinel(67109275);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyAlertsObserver", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendGeolocationUpdate(nsIDOMGeoPosition* aPosition) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GeolocationUpdate(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPosition);
// Sentinel = 'aPosition'
((&(writer__)))->WriteSentinel(303104951);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GeolocationUpdate", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendGeolocationError(const uint16_t& errorCode) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GeolocationError(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), errorCode);
// Sentinel = 'errorCode'
((&(writer__)))->WriteSentinel(312345510);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GeolocationError", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendUpdateDictionaryList(mozilla::Span<nsCString const> dictionaries) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateDictionaryList(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), dictionaries);
// Sentinel = 'dictionaries'
((&(writer__)))->WriteSentinel(540738815);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateDictionaryList", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendUpdateFontList(const SystemFontList& fontList) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateFontList(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), fontList);
// Sentinel = 'fontList'
((&(writer__)))->WriteSentinel(249430868);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateFontList", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendRebuildFontList(const bool& aFullRebuild) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RebuildFontList(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aFullRebuild);
// Sentinel = 'aFullRebuild'
((&(writer__)))->WriteSentinel(506004668);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RebuildFontList", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendFontListChanged() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_FontListChanged(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_FontListChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendForceGlobalReflow(const bool& aNeedsReframe) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ForceGlobalReflow(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aNeedsReframe);
// Sentinel = 'aNeedsReframe'
((&(writer__)))->WriteSentinel(583730451);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ForceGlobalReflow", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendFontListShmBlockAdded(
const uint32_t& aGeneration,
const uint32_t& aIndex,
SharedMemoryHandle&& aHandle) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_FontListShmBlockAdded(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);
IPC::WriteParam((&(writer__)), std::move(aHandle));
// Sentinel = 'aHandle'
((&(writer__)))->WriteSentinel(174326446);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_FontListShmBlockAdded", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendUpdateAppLocales(mozilla::Span<nsCString const> appLocales) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateAppLocales(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), appLocales);
// Sentinel = 'appLocales'
((&(writer__)))->WriteSentinel(367395845);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateAppLocales", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendUpdateRequestedLocales(mozilla::Span<nsCString const> requestedLocales) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateRequestedLocales(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), requestedLocales);
// Sentinel = 'requestedLocales'
((&(writer__)))->WriteSentinel(951977622);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateRequestedLocales", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendSystemTimezoneChanged() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SystemTimezoneChanged(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SystemTimezoneChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendUpdateL10nFileSources(mozilla::Span<L10nFileSourceDescriptor const> sources) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateL10nFileSources(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), sources);
// Sentinel = 'sources'
((&(writer__)))->WriteSentinel(205325061);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateL10nFileSources", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendRegisterStringBundles(mozilla::Span<StringBundleDescriptor const> stringBundles) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RegisterStringBundles(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), stringBundles);
// Sentinel = 'stringBundles'
((&(writer__)))->WriteSentinel(640484709);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RegisterStringBundles", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendUpdateSharedData(
const FileDescriptor& mapFile,
const uint32_t& aSize,
mozilla::Span<IPCBlob const> blobs,
mozilla::Span<nsCString const> changedKeys) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateSharedData(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), mapFile);
// Sentinel = 'mapFile'
((&(writer__)))->WriteSentinel(185074367);
IPC::WriteParam((&(writer__)), aSize);
// Sentinel = 'aSize'
((&(writer__)))->WriteSentinel(97124861);
IPC::WriteParam((&(writer__)), blobs);
// Sentinel = 'blobs'
((&(writer__)))->WriteSentinel(102957587);
IPC::WriteParam((&(writer__)), changedKeys);
// Sentinel = 'changedKeys'
((&(writer__)))->WriteSentinel(437781607);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateSharedData", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendAddPermission(const Permission& permission) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AddPermission(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), permission);
// Sentinel = 'permission'
((&(writer__)))->WriteSentinel(394921034);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddPermission", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendRemoveAllPermissions() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RemoveAllPermissions(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RemoveAllPermissions", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendFlushMemory(const nsAString& reason) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_FlushMemory(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), reason);
// Sentinel = 'reason'
((&(writer__)))->WriteSentinel(148112009);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_FlushMemory", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendApplicationBackground() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ApplicationBackground(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ApplicationBackground", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendApplicationForeground() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ApplicationForeground(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ApplicationForeground", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendGarbageCollect() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GarbageCollect(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GarbageCollect", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendCycleCollect() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CycleCollect(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CycleCollect", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendUnlinkGhosts() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UnlinkGhosts(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UnlinkGhosts", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendActivateA11y(const uint64_t& aDomains) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ActivateA11y(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aDomains);
// Sentinel = 'aDomains'
((&(writer__)))->WriteSentinel(229966637);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ActivateA11y", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendShutdownA11y() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ShutdownA11y(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ShutdownA11y", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendSetCacheDomains(const uint64_t& aCacheDomains) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetCacheDomains(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aCacheDomains);
// Sentinel = 'aCacheDomains'
((&(writer__)))->WriteSentinel(563873025);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetCacheDomains", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendAppInfo(
const nsACString& version,
const nsACString& buildID,
const nsACString& name,
const nsACString& UAName,
const nsACString& ID,
const nsACString& vendor,
const nsACString& sourceURL,
const nsACString& updateURL) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AppInfo(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), version);
// Sentinel = 'version'
((&(writer__)))->WriteSentinel(204210951);
IPC::WriteParam((&(writer__)), buildID);
// Sentinel = 'buildID'
((&(writer__)))->WriteSentinel(187826846);
IPC::WriteParam((&(writer__)), name);
// Sentinel = 'name'
((&(writer__)))->WriteSentinel(69075362);
IPC::WriteParam((&(writer__)), UAName);
// Sentinel = 'UAName'
((&(writer__)))->WriteSentinel(115540504);
IPC::WriteParam((&(writer__)), ID);
// Sentinel = 'ID'
((&(writer__)))->WriteSentinel(14155918);
IPC::WriteParam((&(writer__)), vendor);
// Sentinel = 'vendor'
((&(writer__)))->WriteSentinel(150405775);
IPC::WriteParam((&(writer__)), sourceURL);
// Sentinel = 'sourceURL'
((&(writer__)))->WriteSentinel(316474245);
IPC::WriteParam((&(writer__)), updateURL);
// Sentinel = 'updateURL'
((&(writer__)))->WriteSentinel(309265271);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AppInfo", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendRemoteType(
const nsACString& aRemoteType,
const nsACString& aProfile) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RemoteType(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aRemoteType);
// Sentinel = 'aRemoteType'
((&(writer__)))->WriteSentinel(437847152);
IPC::WriteParam((&(writer__)), aProfile);
// Sentinel = 'aProfile'
((&(writer__)))->WriteSentinel(237437747);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RemoteType", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendInitRemoteWorkerService(Endpoint<::mozilla::dom::PRemoteWorkerServiceChild>&& aEndpoint) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InitRemoteWorkerService(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitRemoteWorkerService", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendInitBlobURLs(mozilla::Span<BlobURLRegistrationData const> registrations) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InitBlobURLs(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), registrations);
// Sentinel = 'registrations'
((&(writer__)))->WriteSentinel(648873359);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitBlobURLs", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendInitJSActorInfos(
mozilla::Span<JSProcessActorInfo const> aContentInfos,
mozilla::Span<JSWindowActorInfo const> aWindowInfos) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InitJSActorInfos(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContentInfos);
// Sentinel = 'aContentInfos'
((&(writer__)))->WriteSentinel(600638780);
IPC::WriteParam((&(writer__)), aWindowInfos);
// Sentinel = 'aWindowInfos'
((&(writer__)))->WriteSentinel(518522073);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitJSActorInfos", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendUnregisterJSWindowActor(const nsACString& name) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UnregisterJSWindowActor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), name);
// Sentinel = 'name'
((&(writer__)))->WriteSentinel(69075362);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UnregisterJSWindowActor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendUnregisterJSProcessActor(const nsACString& name) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UnregisterJSProcessActor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), name);
// Sentinel = 'name'
((&(writer__)))->WriteSentinel(69075362);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UnregisterJSProcessActor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendSetXPCOMProcessAttributes(
const XPCOMInitData& xpcomInit,
const StructuredCloneData& initialData,
const FullLookAndFeel& lookAndFeeldata,
const SystemFontList& systemFontList,
mozilla::Maybe<SharedMemoryHandle>&& sharedUASheetHandle,
const uintptr_t& sharedUASheetAddress,
nsTArray<SharedMemoryHandle>&& sharedFontListBlocks,
const bool& aIsStartingUp) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetXPCOMProcessAttributes(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), xpcomInit);
// Sentinel = 'xpcomInit'
((&(writer__)))->WriteSentinel(316998588);
IPC::WriteParam((&(writer__)), initialData);
// Sentinel = 'initialData'
((&(writer__)))->WriteSentinel(451413093);
IPC::WriteParam((&(writer__)), lookAndFeeldata);
// Sentinel = 'lookAndFeeldata'
((&(writer__)))->WriteSentinel(790627807);
IPC::WriteParam((&(writer__)), systemFontList);
// Sentinel = 'systemFontList'
((&(writer__)))->WriteSentinel(746194393);
IPC::WriteParam((&(writer__)), std::move(sharedUASheetHandle));
// Sentinel = 'sharedUASheetHandle'
((&(writer__)))->WriteSentinel(1232406355);
IPC::WriteParam((&(writer__)), sharedUASheetAddress);
// Sentinel = 'sharedUASheetAddress'
((&(writer__)))->WriteSentinel(1361643469);
IPC::WriteParam((&(writer__)), std::move(sharedFontListBlocks));
// Sentinel = 'sharedFontListBlocks'
((&(writer__)))->WriteSentinel(1412827145);
IPC::WriteParam((&(writer__)), aIsStartingUp);
// Sentinel = 'aIsStartingUp'
((&(writer__)))->WriteSentinel(597361967);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetXPCOMProcessAttributes", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendLastPrivateDocShellDestroyed() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_LastPrivateDocShellDestroyed(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_LastPrivateDocShellDestroyed", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendNotifyProcessPriorityChanged(const ProcessPriority& priority) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyProcessPriorityChanged(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), priority);
// Sentinel = 'priority'
((&(writer__)))->WriteSentinel(262865795);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyProcessPriorityChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendMinimizeMemoryUsage() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_MinimizeMemoryUsage(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_MinimizeMemoryUsage", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendLoadAndRegisterSheet(
nsIURI* uri,
const uint32_t& type) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_LoadAndRegisterSheet(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), uri);
// Sentinel = 'uri'
((&(writer__)))->WriteSentinel(45023569);
IPC::WriteParam((&(writer__)), type);
// Sentinel = 'type'
((&(writer__)))->WriteSentinel(75760067);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_LoadAndRegisterSheet", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendUnregisterSheet(
nsIURI* uri,
const uint32_t& type) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UnregisterSheet(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), uri);
// Sentinel = 'uri'
((&(writer__)))->WriteSentinel(45023569);
IPC::WriteParam((&(writer__)), type);
// Sentinel = 'type'
((&(writer__)))->WriteSentinel(75760067);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UnregisterSheet", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendNotifyIdleObserver(
const uint64_t& observerId,
const nsACString& topic,
const nsAString& str) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyIdleObserver(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), observerId);
// Sentinel = 'observerId'
((&(writer__)))->WriteSentinel(386335766);
IPC::WriteParam((&(writer__)), topic);
// Sentinel = 'topic'
((&(writer__)))->WriteSentinel(109707808);
IPC::WriteParam((&(writer__)), str);
// Sentinel = 'str'
((&(writer__)))->WriteSentinel(45482330);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyIdleObserver", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendDomainSetChanged(
const uint32_t& aSetType,
const uint32_t& aChangeType,
nsIURI* aDomain) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_DomainSetChanged(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aSetType);
// Sentinel = 'aSetType'
((&(writer__)))->WriteSentinel(234292016);
IPC::WriteParam((&(writer__)), aChangeType);
// Sentinel = 'aChangeType'
((&(writer__)))->WriteSentinel(417924170);
IPC::WriteParam((&(writer__)), aDomain);
// Sentinel = 'aDomain'
((&(writer__)))->WriteSentinel(176685754);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_DomainSetChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendShutdownConfirmedHP() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ShutdownConfirmedHP(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ShutdownConfirmedHP", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendShutdown() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_Shutdown(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_Shutdown", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendLoadProcessScript(const nsAString& url) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_LoadProcessScript(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), url);
// Sentinel = 'url'
((&(writer__)))->WriteSentinel(45220180);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_LoadProcessScript", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendUpdateWindow(const uintptr_t& aChildId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateWindow(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aChildId);
// Sentinel = 'aChildId'
((&(writer__)))->WriteSentinel(221512435);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateWindow", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendNotifyEmptyHTTPCache() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyEmptyHTTPCache(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyEmptyHTTPCache", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendPush(
const nsACString& scope,
nsIPrincipal* principal,
const nsAString& messageId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_Push(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), scope);
// Sentinel = 'scope'
((&(writer__)))->WriteSentinel(107086363);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
IPC::WriteParam((&(writer__)), messageId);
// Sentinel = 'messageId'
((&(writer__)))->WriteSentinel(310576019);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_Push", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendPushWithData(
const nsACString& scope,
nsIPrincipal* principal,
const nsAString& messageId,
mozilla::Span<uint8_t const> data) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_PushWithData(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), scope);
// Sentinel = 'scope'
((&(writer__)))->WriteSentinel(107086363);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
IPC::WriteParam((&(writer__)), messageId);
// Sentinel = 'messageId'
((&(writer__)))->WriteSentinel(310576019);
IPC::WriteParam((&(writer__)), data);
// Sentinel = 'data'
((&(writer__)))->WriteSentinel(67109275);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PushWithData", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendPushSubscriptionChange(
const nsACString& scope,
nsIPrincipal* principal) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_PushSubscriptionChange(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), scope);
// Sentinel = 'scope'
((&(writer__)))->WriteSentinel(107086363);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PushSubscriptionChange", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendGetFilesResponse(
const nsID& aID,
const GetFilesResponseResult& aResult) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GetFilesResponse(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aID);
// Sentinel = 'aID'
((&(writer__)))->WriteSentinel(33292527);
IPC::WriteParam((&(writer__)), aResult);
// Sentinel = 'aResult'
((&(writer__)))->WriteSentinel(185205473);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetFilesResponse", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendBlobURLRegistration(
const nsACString& aURI,
const IPCBlob& aBlob,
nsIPrincipal* aPrincipal,
const nsACString& aPartitionKey) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_BlobURLRegistration(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aURI);
// Sentinel = 'aURI'
((&(writer__)))->WriteSentinel(57934162);
IPC::WriteParam((&(writer__)), aBlob);
// Sentinel = 'aBlob'
((&(writer__)))->WriteSentinel(91619809);
IPC::WriteParam((&(writer__)), aPrincipal);
// Sentinel = 'aPrincipal'
((&(writer__)))->WriteSentinel(364381188);
IPC::WriteParam((&(writer__)), aPartitionKey);
// Sentinel = 'aPartitionKey'
((&(writer__)))->WriteSentinel(610141509);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_BlobURLRegistration", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendBlobURLUnregistration(const nsACString& aURI) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_BlobURLUnregistration(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aURI);
// Sentinel = 'aURI'
((&(writer__)))->WriteSentinel(57934162);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_BlobURLUnregistration", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendGMPsChanged(mozilla::Span<GMPCapabilityData const> capabilities) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GMPsChanged(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), capabilities);
// Sentinel = 'capabilities'
((&(writer__)))->WriteSentinel(527434987);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GMPsChanged", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendProvideAnonymousTemporaryFile(
const uint64_t& aID,
const FileDescOrError& aFD) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ProvideAnonymousTemporaryFile(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aID);
// Sentinel = 'aID'
((&(writer__)))->WriteSentinel(33292527);
IPC::WriteParam((&(writer__)), aFD);
// Sentinel = 'aFD'
((&(writer__)))->WriteSentinel(32899308);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ProvideAnonymousTemporaryFile", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendSetPermissionsWithKey(
const nsACString& aPermissionKey,
mozilla::Span<Permission const> aPermissions) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetPermissionsWithKey(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aPermissionKey);
// Sentinel = 'aPermissionKey'
((&(writer__)))->WriteSentinel(708511156);
IPC::WriteParam((&(writer__)), aPermissions);
// Sentinel = 'aPermissions'
((&(writer__)))->WriteSentinel(527697150);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetPermissionsWithKey", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendRefreshScreens(mozilla::Span<ScreenDetails const> aScreens) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RefreshScreens(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aScreens);
// Sentinel = 'aScreens'
((&(writer__)))->WriteSentinel(234029877);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RefreshScreens", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendShareCodeCoverageMutex(CrossProcessMutexHandle&& handle) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ShareCodeCoverageMutex(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), std::move(handle));
// Sentinel = 'handle'
((&(writer__)))->WriteSentinel(142344813);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ShareCodeCoverageMutex", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendFlushCodeCoverageCounters(
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_FlushCodeCoverageCounters(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_FlushCodeCoverageCounters", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_FlushCodeCoverageCounters__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentParent::SendFlushCodeCoverageCounters() -> RefPtr<FlushCodeCoverageCountersPromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendFlushCodeCoverageCounters([promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentParent::SendSetInputEventQueueEnabled() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetInputEventQueueEnabled(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetInputEventQueueEnabled", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendFlushInputEventQueue() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_FlushInputEventQueue(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_FlushInputEventQueue", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendResumeInputEventQueue() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ResumeInputEventQueue(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ResumeInputEventQueue", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendSuspendInputEventQueue() -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SuspendInputEventQueue(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SuspendInputEventQueue", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendAddDynamicScalars(mozilla::Span<DynamicScalarDefinition const> definitions) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AddDynamicScalars(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), definitions);
// Sentinel = 'definitions'
((&(writer__)))->WriteSentinel(455279773);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddDynamicScalars", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendCrossProcessRedirect(
const RedirectToRealChannelArgs& args,
nsTArray<Endpoint<::mozilla::extensions::PStreamFilterParent>>&& aEndpoint,
mozilla::ipc::ResolveCallback<nsresult>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CrossProcessRedirect(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), args);
// Sentinel = 'args'
((&(writer__)))->WriteSentinel(69140910);
IPC::WriteParam((&(writer__)), std::move(aEndpoint));
// Sentinel = 'aEndpoint'
((&(writer__)))->WriteSentinel(292225955);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CrossProcessRedirect", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_CrossProcessRedirect__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentParent::SendCrossProcessRedirect(
const RedirectToRealChannelArgs& args,
nsTArray<Endpoint<::mozilla::extensions::PStreamFilterParent>>&& aEndpoint) -> RefPtr<CrossProcessRedirectPromise>
{
RefPtr<MozPromise<nsresult, ResponseRejectReason, true>::Private> promise__ = new MozPromise<nsresult, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendCrossProcessRedirect(std::move(args), std::move(aEndpoint), [promise__](nsresult&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentParent::SendStartDelayedAutoplayMediaComponents(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_StartDelayedAutoplayMediaComponents(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_StartDelayedAutoplayMediaComponents", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendUpdateMediaControlAction(
const MaybeDiscardedBrowsingContext& aContext,
const MediaControlAction& aAction) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateMediaControlAction(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);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateMediaControlAction", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendRegisterBrowsingContextGroup(
const uint64_t& aGroupId,
mozilla::Span<SyncedContextInitializer const> aInits) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RegisterBrowsingContextGroup(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aGroupId);
// Sentinel = 'aGroupId'
((&(writer__)))->WriteSentinel(233964316);
IPC::WriteParam((&(writer__)), aInits);
// Sentinel = 'aInits'
((&(writer__)))->WriteSentinel(134677097);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_RegisterBrowsingContextGroup", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendDestroyBrowsingContextGroup(const uint64_t& aGroupId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_DestroyBrowsingContextGroup(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aGroupId);
// Sentinel = 'aGroupId'
((&(writer__)))->WriteSentinel(233964316);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_DestroyBrowsingContextGroup", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendInitSandboxTesting(Endpoint<::mozilla::PSandboxTestingChild>&& aEndpoint) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InitSandboxTesting(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitSandboxTesting", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendLoadURI(
const MaybeDiscardedBrowsingContext& aContext,
mozilla::NotNull<nsDocShellLoadState*> aLoadState,
const bool& aSetNavigating,
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_LoadURI(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aLoadState);
// Sentinel = 'aLoadState'
((&(writer__)))->WriteSentinel(349570019);
IPC::WriteParam((&(writer__)), aSetNavigating);
// Sentinel = 'aSetNavigating'
((&(writer__)))->WriteSentinel(686556566);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_LoadURI", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_LoadURI__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentParent::SendLoadURI(
const MaybeDiscardedBrowsingContext& aContext,
mozilla::NotNull<nsDocShellLoadState*> aLoadState,
const bool& aSetNavigating) -> RefPtr<LoadURIPromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendLoadURI(std::move(aContext), std::move(aLoadState), std::move(aSetNavigating), [promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentParent::SendInternalLoad(mozilla::NotNull<nsDocShellLoadState*> aLoadState) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InternalLoad(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aLoadState);
// Sentinel = 'aLoadState'
((&(writer__)))->WriteSentinel(349570019);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InternalLoad", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendDisplayLoadError(
const MaybeDiscardedBrowsingContext& aContext,
const nsAString& aURI) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_DisplayLoadError(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aURI);
// Sentinel = 'aURI'
((&(writer__)))->WriteSentinel(57934162);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_DisplayLoadError", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendGoBack(
const MaybeDiscardedBrowsingContext& aContext,
const mozilla::Maybe<int32_t>& aCancelContentJSEpoch,
const bool& aRequireUserInteraction,
const bool& aUserActivation) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GoBack(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aCancelContentJSEpoch);
// Sentinel = 'aCancelContentJSEpoch'
((&(writer__)))->WriteSentinel(1473841167);
IPC::WriteParam((&(writer__)), aRequireUserInteraction);
// Sentinel = 'aRequireUserInteraction'
((&(writer__)))->WriteSentinel(1862076766);
IPC::WriteParam((&(writer__)), aUserActivation);
// Sentinel = 'aUserActivation'
((&(writer__)))->WriteSentinel(794887699);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GoBack", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendGoForward(
const MaybeDiscardedBrowsingContext& aContext,
const mozilla::Maybe<int32_t>& aCancelContentJSEpoch,
const bool& aRequireUserInteraction,
const bool& aUserActivation) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GoForward(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aCancelContentJSEpoch);
// Sentinel = 'aCancelContentJSEpoch'
((&(writer__)))->WriteSentinel(1473841167);
IPC::WriteParam((&(writer__)), aRequireUserInteraction);
// Sentinel = 'aRequireUserInteraction'
((&(writer__)))->WriteSentinel(1862076766);
IPC::WriteParam((&(writer__)), aUserActivation);
// Sentinel = 'aUserActivation'
((&(writer__)))->WriteSentinel(794887699);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GoForward", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendGoToIndex(
const MaybeDiscardedBrowsingContext& aContext,
const int32_t& aIndex,
const mozilla::Maybe<int32_t>& aCancelContentJSEpoch,
const bool& aUserActivation) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GoToIndex(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aIndex);
// Sentinel = 'aIndex'
((&(writer__)))->WriteSentinel(132055642);
IPC::WriteParam((&(writer__)), aCancelContentJSEpoch);
// Sentinel = 'aCancelContentJSEpoch'
((&(writer__)))->WriteSentinel(1473841167);
IPC::WriteParam((&(writer__)), aUserActivation);
// Sentinel = 'aUserActivation'
((&(writer__)))->WriteSentinel(794887699);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GoToIndex", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendReload(
const MaybeDiscardedBrowsingContext& aContext,
const uint32_t& aReloadFlags) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_Reload(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_Reload", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendStopLoad(
const MaybeDiscardedBrowsingContext& aContext,
const uint32_t& aStopFlags) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_StopLoad(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aStopFlags);
// Sentinel = 'aStopFlags'
((&(writer__)))->WriteSentinel(360317941);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_StopLoad", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendOnAllowAccessFor(
const MaybeDiscardedBrowsingContext& aParentContext,
const nsACString& aTrackingOrigin,
const uint32_t& aCookieBehavior,
const StorageAccessPermissionGrantedReason& aReason) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_OnAllowAccessFor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aParentContext);
// Sentinel = 'aParentContext'
((&(writer__)))->WriteSentinel(692454833);
IPC::WriteParam((&(writer__)), aTrackingOrigin);
// Sentinel = 'aTrackingOrigin'
((&(writer__)))->WriteSentinel(792331773);
IPC::WriteParam((&(writer__)), aCookieBehavior);
// Sentinel = 'aCookieBehavior'
((&(writer__)))->WriteSentinel(772408812);
IPC::WriteParam((&(writer__)), aReason);
// Sentinel = 'aReason'
((&(writer__)))->WriteSentinel(180093642);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_OnAllowAccessFor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendOnContentBlockingDecision(
const MaybeDiscardedBrowsingContext& aContext,
const BlockingDecision& aReason,
const uint32_t& aRejectedReason) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_OnContentBlockingDecision(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aReason);
// Sentinel = 'aReason'
((&(writer__)))->WriteSentinel(180093642);
IPC::WriteParam((&(writer__)), aRejectedReason);
// Sentinel = 'aRejectedReason'
((&(writer__)))->WriteSentinel(781059568);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_OnContentBlockingDecision", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendAbortOrientationPendingPromises(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AbortOrientationPendingPromises(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_AbortOrientationPendingPromises", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendHistoryCommitIndexAndLength(
const MaybeDiscardedBrowsingContext& aContext,
const uint32_t& aIndex,
const uint32_t& aLength,
const nsID& aChangeID) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_HistoryCommitIndexAndLength(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aIndex);
// Sentinel = 'aIndex'
((&(writer__)))->WriteSentinel(132055642);
IPC::WriteParam((&(writer__)), aLength);
// Sentinel = 'aLength'
((&(writer__)))->WriteSentinel(179045060);
IPC::WriteParam((&(writer__)), aChangeID);
// Sentinel = 'aChangeID'
((&(writer__)))->WriteSentinel(275710773);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_HistoryCommitIndexAndLength", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendGetLayoutHistoryState(
const MaybeDiscardedBrowsingContext& aContext,
mozilla::ipc::ResolveCallback<std::tuple<RefPtr<nsILayoutHistoryState>, mozilla::Maybe<Wireframe>>>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_GetLayoutHistoryState(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetLayoutHistoryState", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_GetLayoutHistoryState__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentParent::SendGetLayoutHistoryState(const MaybeDiscardedBrowsingContext& aContext) -> RefPtr<GetLayoutHistoryStatePromise>
{
RefPtr<MozPromise<std::tuple<RefPtr<nsILayoutHistoryState>, mozilla::Maybe<Wireframe>>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<std::tuple<RefPtr<nsILayoutHistoryState>, mozilla::Maybe<Wireframe>>, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendGetLayoutHistoryState(std::move(aContext), [promise__](std::tuple<RefPtr<nsILayoutHistoryState>, mozilla::Maybe<Wireframe>>&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentParent::SendDispatchLocationChangeEvent(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_DispatchLocationChangeEvent(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_DispatchLocationChangeEvent", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendDispatchBeforeUnloadToSubtree(
const MaybeDiscardedBrowsingContext& aStartingAt,
mozilla::ipc::ResolveCallback<PermitUnloadResult>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_DispatchBeforeUnloadToSubtree(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aStartingAt);
// Sentinel = 'aStartingAt'
((&(writer__)))->WriteSentinel(441844835);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_DispatchBeforeUnloadToSubtree", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_DispatchBeforeUnloadToSubtree__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentParent::SendDispatchBeforeUnloadToSubtree(const MaybeDiscardedBrowsingContext& aStartingAt) -> RefPtr<DispatchBeforeUnloadToSubtreePromise>
{
RefPtr<MozPromise<PermitUnloadResult, ResponseRejectReason, true>::Private> promise__ = new MozPromise<PermitUnloadResult, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendDispatchBeforeUnloadToSubtree(std::move(aStartingAt), [promise__](PermitUnloadResult&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentParent::SendUpdateMediaCodecsSupported(
const RemoteDecodeIn& aLocation,
const MediaCodecsSupported& aSupported) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateMediaCodecsSupported(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aLocation);
// Sentinel = 'aLocation'
((&(writer__)))->WriteSentinel(292094875);
IPC::WriteParam((&(writer__)), aSupported);
// Sentinel = 'aSupported'
((&(writer__)))->WriteSentinel(378799144);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateMediaCodecsSupported", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendInitNextGenLocalStorageEnabled(const bool& enabled) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_InitNextGenLocalStorageEnabled(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), enabled);
// Sentinel = 'enabled'
((&(writer__)))->WriteSentinel(188547788);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitNextGenLocalStorageEnabled", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendPRemotePrintJobConstructor(PRemotePrintJobParent* actor) -> PRemotePrintJobParent*
{
if (!actor) {
NS_WARNING("Cannot bind null PRemotePrintJobParent actor");
return nullptr;
}
if (!actor->SetManagerAndRegister(this)) {
NS_WARNING("Failed to bind PRemotePrintJobParent actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PContent::Msg_PRemotePrintJobConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PRemotePrintJobConstructor", 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 PRemotePrintJobParent constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PContentParent::SendScriptError(
const nsAString& message,
const nsACString& sourceName,
const uint32_t& lineNumber,
const uint32_t& colNumber,
const uint32_t& flags,
const nsACString& category,
const bool& isFromPrivateWindow,
const uint64_t& innerWindowId,
const bool& isFromChromeContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ScriptError(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), message);
// Sentinel = 'message'
((&(writer__)))->WriteSentinel(197198566);
IPC::WriteParam((&(writer__)), sourceName);
// Sentinel = 'sourceName'
((&(writer__)))->WriteSentinel(387580947);
IPC::WriteParam((&(writer__)), lineNumber);
// Sentinel = 'lineNumber'
((&(writer__)))->WriteSentinel(374932498);
IPC::WriteParam((&(writer__)), colNumber);
// Sentinel = 'colNumber'
((&(writer__)))->WriteSentinel(304284584);
IPC::WriteParam((&(writer__)), flags);
// Sentinel = 'flags'
((&(writer__)))->WriteSentinel(102171150);
IPC::WriteParam((&(writer__)), category);
// Sentinel = 'category'
((&(writer__)))->WriteSentinel(247333727);
IPC::WriteParam((&(writer__)), isFromPrivateWindow);
// Sentinel = 'isFromPrivateWindow'
((&(writer__)))->WriteSentinel(1288964036);
IPC::WriteParam((&(writer__)), innerWindowId);
// Sentinel = 'innerWindowId'
((&(writer__)))->WriteSentinel(627967298);
IPC::WriteParam((&(writer__)), isFromChromeContext);
// Sentinel = 'isFromChromeContext'
((&(writer__)))->WriteSentinel(1269368756);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendReportFrameTimingData(
const LoadInfoArgs& loadInfo,
const nsAString& entryName,
const nsAString& initiatorType,
const UniquePtr<PerformanceTimingData>& aData) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ReportFrameTimingData(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), loadInfo);
// Sentinel = 'loadInfo'
((&(writer__)))->WriteSentinel(240386861);
IPC::WriteParam((&(writer__)), entryName);
// Sentinel = 'entryName'
((&(writer__)))->WriteSentinel(315950004);
IPC::WriteParam((&(writer__)), initiatorType);
// Sentinel = 'initiatorType'
((&(writer__)))->WriteSentinel(642647414);
IPC::WriteParam((&(writer__)), aData);
// Sentinel = 'aData'
((&(writer__)))->WriteSentinel(90571228);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendCommitBrowsingContextTransaction(
const MaybeDiscardedBrowsingContext& aContext,
const BrowsingContextTransaction& aTransaction,
const uint64_t& aEpoch) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CommitBrowsingContextTransaction(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aTransaction);
// Sentinel = 'aTransaction'
((&(writer__)))->WriteSentinel(523371752);
IPC::WriteParam((&(writer__)), aEpoch);
// Sentinel = 'aEpoch'
((&(writer__)))->WriteSentinel(132121169);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendAsyncMessage(
const nsAString& aMessage,
const ClonedMessageData& aData) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AsyncMessage(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aMessage);
// Sentinel = 'aMessage'
((&(writer__)))->WriteSentinel(233440039);
IPC::WriteParam((&(writer__)), aData);
// Sentinel = 'aData'
((&(writer__)))->WriteSentinel(90571228);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendNotifyPushSubscriptionModifiedObservers(
const nsACString& scope,
nsIPrincipal* principal) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyPushSubscriptionModifiedObservers(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), scope);
// Sentinel = 'scope'
((&(writer__)))->WriteSentinel(107086363);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushSubscriptionModifiedObservers", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendPushError(
const nsACString& scope,
nsIPrincipal* principal,
const nsAString& message,
const uint32_t& flags) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_PushError(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), scope);
// Sentinel = 'scope'
((&(writer__)))->WriteSentinel(107086363);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
IPC::WriteParam((&(writer__)), message);
// Sentinel = 'message'
((&(writer__)))->WriteSentinel(197198566);
IPC::WriteParam((&(writer__)), flags);
// Sentinel = 'flags'
((&(writer__)))->WriteSentinel(102171150);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_PushError", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendCreateBrowsingContext(
const uint64_t& aGroupId,
const BrowsingContextInitializer& aInit) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateBrowsingContext(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aGroupId);
// Sentinel = 'aGroupId'
((&(writer__)))->WriteSentinel(233964316);
IPC::WriteParam((&(writer__)), aInit);
// Sentinel = 'aInit'
((&(writer__)))->WriteSentinel(94241270);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendDiscardBrowsingContext(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aDoDiscard,
mozilla::ipc::ResolveCallback<uint64_t>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_DiscardBrowsingContext(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aDoDiscard);
// Sentinel = 'aDoDiscard'
((&(writer__)))->WriteSentinel(339215311);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_DiscardBrowsingContext", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_DiscardBrowsingContext__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentParent::SendDiscardBrowsingContext(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aDoDiscard) -> RefPtr<DiscardBrowsingContextPromise>
{
RefPtr<MozPromise<uint64_t, ResponseRejectReason, true>::Private> promise__ = new MozPromise<uint64_t, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendDiscardBrowsingContext(std::move(aContext), std::move(aDoDiscard), [promise__](uint64_t&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentParent::SendAdjustWindowFocus(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aIsVisible,
const uint64_t& aActionId,
const bool& aShouldClearAncestorFocus,
const MaybeDiscardedBrowsingContext& aAncestorBrowsingContextToFocus) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_AdjustWindowFocus(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aIsVisible);
// Sentinel = 'aIsVisible'
((&(writer__)))->WriteSentinel(353567724);
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
IPC::WriteParam((&(writer__)), aShouldClearAncestorFocus);
// Sentinel = 'aShouldClearAncestorFocus'
((&(writer__)))->WriteSentinel(2138442231);
IPC::WriteParam((&(writer__)), aAncestorBrowsingContextToFocus);
// Sentinel = 'aAncestorBrowsingContextToFocus'
((&(writer__)))->WriteSentinel(3344239764);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendWindowClose(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aTrustedCaller) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_WindowClose(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aTrustedCaller);
// Sentinel = 'aTrustedCaller'
((&(writer__)))->WriteSentinel(706479520);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendWindowFocus(
const MaybeDiscardedBrowsingContext& aContext,
const CallerType& aCallerType,
const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_WindowFocus(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aCallerType);
// Sentinel = 'aCallerType'
((&(writer__)))->WriteSentinel(422118487);
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendWindowBlur(
const MaybeDiscardedBrowsingContext& aContext,
const CallerType& aCallerType) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_WindowBlur(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aCallerType);
// Sentinel = 'aCallerType'
((&(writer__)))->WriteSentinel(422118487);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendRaiseWindow(
const MaybeDiscardedBrowsingContext& aContext,
const CallerType& aCallerType,
const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_RaiseWindow(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aCallerType);
// Sentinel = 'aCallerType'
((&(writer__)))->WriteSentinel(422118487);
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendClearFocus(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ClearFocus(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendSetFocusedBrowsingContext(
const MaybeDiscardedBrowsingContext& aContext,
const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetFocusedBrowsingContext(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendSetActiveBrowsingContext(
const MaybeDiscardedBrowsingContext& aContext,
const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetActiveBrowsingContext(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendUnsetActiveBrowsingContext(
const MaybeDiscardedBrowsingContext& aContext,
const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_UnsetActiveBrowsingContext(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendSetFocusedElement(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aNeedsFocus) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetFocusedElement(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aNeedsFocus);
// Sentinel = 'aNeedsFocus'
((&(writer__)))->WriteSentinel(419759185);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendFinalizeFocusOuter(
const MaybeDiscardedBrowsingContext& aContext,
const bool& aCanFocus,
const CallerType& aCallerType) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_FinalizeFocusOuter(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aCanFocus);
// Sentinel = 'aCanFocus'
((&(writer__)))->WriteSentinel(275055476);
IPC::WriteParam((&(writer__)), aCallerType);
// Sentinel = 'aCallerType'
((&(writer__)))->WriteSentinel(422118487);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendBlurToChild(
const MaybeDiscardedBrowsingContext& aFocusedBrowsingContext,
const MaybeDiscardedBrowsingContext& aBrowsingContextToClear,
const MaybeDiscardedBrowsingContext& aAncestorBrowsingContextToFocus,
const bool& aIsLeavingDocument,
const bool& aAdjustWidget,
const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_BlurToChild(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__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_BlurToChild", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendSetupFocusedAndActive(
const MaybeDiscardedBrowsingContext& aFocusedBrowsingContext,
const uint64_t& aActionIdForFocused,
const MaybeDiscardedBrowsingContext& aActiveBrowsingContext,
const uint64_t& aActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_SetupFocusedAndActive(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aFocusedBrowsingContext);
// Sentinel = 'aFocusedBrowsingContext'
((&(writer__)))->WriteSentinel(1842153819);
IPC::WriteParam((&(writer__)), aActionIdForFocused);
// Sentinel = 'aActionIdForFocused'
((&(writer__)))->WriteSentinel(1211303773);
IPC::WriteParam((&(writer__)), aActiveBrowsingContext);
// Sentinel = 'aActiveBrowsingContext'
((&(writer__)))->WriteSentinel(1678444782);
IPC::WriteParam((&(writer__)), aActionId);
// Sentinel = 'aActionId'
((&(writer__)))->WriteSentinel(284164973);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetupFocusedAndActive", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendReviseActiveBrowsingContext(
const uint64_t& aOldActionId,
const MaybeDiscardedBrowsingContext& aActiveBrowsingContext,
const uint64_t& aNewActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ReviseActiveBrowsingContext(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aOldActionId);
// Sentinel = 'aOldActionId'
((&(writer__)))->WriteSentinel(490144908);
IPC::WriteParam((&(writer__)), aActiveBrowsingContext);
// Sentinel = 'aActiveBrowsingContext'
((&(writer__)))->WriteSentinel(1678444782);
IPC::WriteParam((&(writer__)), aNewActionId);
// Sentinel = 'aNewActionId'
((&(writer__)))->WriteSentinel(496043159);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReviseActiveBrowsingContext", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendReviseFocusedBrowsingContext(
const uint64_t& aOldActionId,
const MaybeDiscardedBrowsingContext& aFocusedBrowsingContext,
const uint64_t& aNewActionId) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_ReviseFocusedBrowsingContext(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aOldActionId);
// Sentinel = 'aOldActionId'
((&(writer__)))->WriteSentinel(490144908);
IPC::WriteParam((&(writer__)), aFocusedBrowsingContext);
// Sentinel = 'aFocusedBrowsingContext'
((&(writer__)))->WriteSentinel(1842153819);
IPC::WriteParam((&(writer__)), aNewActionId);
// Sentinel = 'aNewActionId'
((&(writer__)))->WriteSentinel(496043159);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReviseFocusedBrowsingContext", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendMaybeExitFullscreen(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_MaybeExitFullscreen(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendWindowPostMessage(
const MaybeDiscardedBrowsingContext& aContext,
const ClonedOrErrorMessageData& aMessage,
const PostMessageData& aData) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_WindowPostMessage(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aMessage);
// Sentinel = 'aMessage'
((&(writer__)))->WriteSentinel(233440039);
IPC::WriteParam((&(writer__)), aData);
// Sentinel = 'aData'
((&(writer__)))->WriteSentinel(90571228);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendCommitWindowContextTransaction(
const MaybeDiscardedWindowContext& aContext,
const WindowContextTransaction& aTransaction,
const uint64_t& aEpoch) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CommitWindowContextTransaction(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContext);
// Sentinel = 'aContext'
((&(writer__)))->WriteSentinel(235406151);
IPC::WriteParam((&(writer__)), aTransaction);
// Sentinel = 'aTransaction'
((&(writer__)))->WriteSentinel(523371752);
IPC::WriteParam((&(writer__)), aEpoch);
// Sentinel = 'aEpoch'
((&(writer__)))->WriteSentinel(132121169);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
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 PContentParent::SendCreateWindowContext(const WindowContextInitializer& aInit) -> bool
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateWindowContext(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aInit);
// Sentinel = 'aInit'
((&(writer__)))->WriteSentinel(94241270);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateWindowContext", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PContentParent::SendDiscardWindowContext(
const uint64_t& aContextId,
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_DiscardWindowContext(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContextId);
// Sentinel = 'aContextId'
((&(writer__)))->WriteSentinel(361497588);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_DiscardWindowContext", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_DiscardWindowContext__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentParent::SendDiscardWindowContext(const uint64_t& aContextId) -> RefPtr<DiscardWindowContextPromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendDiscardWindowContext(std::move(aContextId), [promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentParent::SendFlushFOGData(
mozilla::ipc::ResolveCallback<ByteBuf>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PContent::Msg_FlushFOGData(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PContent::Msg_FlushFOGData", OTHER);
ChannelSend(std::move(msg__), PContent::Reply_FlushFOGData__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PContentParent::SendFlushFOGData() -> RefPtr<FlushFOGDataPromise>
{
RefPtr<MozPromise<ByteBuf, ResponseRejectReason, true>::Private> promise__ = new MozPromise<ByteBuf, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendFlushFOGData([promise__](ByteBuf&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PContentParent::DeallocManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
switch (aProtocolId) {
case PContentPermissionRequestMsgStart:
static_cast<ContentParent*>(this)->DeallocPContentPermissionRequestParent(static_cast<PContentPermissionRequestParent*>(aListener));
return;
case PCycleCollectWithLogsMsgStart:
static_cast<ContentParent*>(this)->DeallocPCycleCollectWithLogsParent(static_cast<PCycleCollectWithLogsParent*>(aListener));
return;
case PHalMsgStart:
static_cast<ContentParent*>(this)->DeallocPHalParent(static_cast<PHalParent*>(aListener));
return;
case PHeapSnapshotTempFileHelperMsgStart:
static_cast<ContentParent*>(this)->DeallocPHeapSnapshotTempFileHelperParent(static_cast<PHeapSnapshotTempFileHelperParent*>(aListener));
return;
case PMediaMsgStart:
static_cast<ContentParent*>(this)->DeallocPMediaParent(static_cast<PMediaParent*>(aListener));
return;
case PRemoteSpellcheckEngineMsgStart:
static_cast<ContentParent*>(this)->DeallocPRemoteSpellcheckEngineParent(static_cast<PRemoteSpellcheckEngineParent*>(aListener));
return;
case PWebrtcGlobalMsgStart:
static_cast<ContentParent*>(this)->DeallocPWebrtcGlobalParent(static_cast<PWebrtcGlobalParent*>(aListener));
return;
case PURLClassifierMsgStart:
static_cast<ContentParent*>(this)->DeallocPURLClassifierParent(static_cast<PURLClassifierParent*>(aListener));
return;
case PURLClassifierLocalMsgStart:
static_cast<ContentParent*>(this)->DeallocPURLClassifierLocalParent(static_cast<PURLClassifierLocalParent*>(aListener));
return;
case PScriptCacheMsgStart:
static_cast<ContentParent*>(this)->DeallocPScriptCacheParent(static_cast<PScriptCacheParent*>(aListener));
return;
case PSessionStorageObserverMsgStart:
static_cast<ContentParent*>(this)->DeallocPSessionStorageObserverParent(static_cast<PSessionStorageObserverParent*>(aListener));
return;
case PBenchmarkStorageMsgStart:
static_cast<ContentParent*>(this)->DeallocPBenchmarkStorageParent(static_cast<PBenchmarkStorageParent*>(aListener));
return;
default:
FatalError("unreached");
return;
}
}
auto PContentParent::OnMessageReceived(const Message& msg__) -> PContentParent::Result
{
int32_t route__ = msg__.routing_id();
if (MSG_ROUTING_CONTROL != route__) {
IProtocol* routed__ = Lookup(route__);
if (!routed__ || !routed__->GetLifecycleProxy()) {
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Ignored message for dead actor",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
RefPtr<mozilla::ipc::ActorLifecycleProxy> proxy__ =
routed__->GetLifecycleProxy();
return proxy__->Get()->OnMessageReceived(msg__);
}
switch (msg__.type()) {
case PContent::Msg_ConstructPopupBrowser__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ConstructPopupBrowser", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__browserEp = IPC::ReadParam<ManagedEndpoint<::mozilla::dom::PBrowserParent>>((&(reader__)));
if (!maybe__browserEp) {
FatalError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PBrowserParent>'");
return MsgValueError;
}
auto& browserEp = *maybe__browserEp;
// Sentinel = 'browserEp'
if ((!(((&(reader__)))->ReadSentinel(318833594)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PBrowserParent>'");
return MsgValueError;
}
auto maybe__windowEp = IPC::ReadParam<ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>>((&(reader__)));
if (!maybe__windowEp) {
FatalError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>'");
return MsgValueError;
}
auto& windowEp = *maybe__windowEp;
// Sentinel = 'windowEp'
if ((!(((&(reader__)))->ReadSentinel(255984462)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>'");
return MsgValueError;
}
auto maybe__tabId = IPC::ReadParam<TabId>((&(reader__)));
if (!maybe__tabId) {
FatalError("Error deserializing 'TabId'");
return MsgValueError;
}
auto& tabId = *maybe__tabId;
// Sentinel = 'tabId'
if ((!(((&(reader__)))->ReadSentinel(99156453)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
return MsgValueError;
}
auto maybe__context = IPC::ReadParam<IPCTabContext>((&(reader__)));
if (!maybe__context) {
FatalError("Error deserializing 'IPCTabContext'");
return MsgValueError;
}
auto& context = *maybe__context;
// Sentinel = 'context'
if ((!(((&(reader__)))->ReadSentinel(199164678)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCTabContext'");
return MsgValueError;
}
auto maybe__windowInit = IPC::ReadParam<WindowGlobalInit>((&(reader__)));
if (!maybe__windowInit) {
FatalError("Error deserializing 'WindowGlobalInit'");
return MsgValueError;
}
auto& windowInit = *maybe__windowInit;
// Sentinel = 'windowInit'
if ((!(((&(reader__)))->ReadSentinel(388891693)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WindowGlobalInit'");
return MsgValueError;
}
auto maybe__chromeFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__chromeFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& chromeFlags = *maybe__chromeFlags;
// Sentinel = 'chromeFlags'
if ((!(((&(reader__)))->ReadSentinel(446760044)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvConstructPopupBrowser(std::move(browserEp), std::move(windowEp), std::move(tabId), std::move(context), std::move(windowInit), std::move(chromeFlags));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CloneDocumentTreeInto__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CloneDocumentTreeInto", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aSourceBc = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aSourceBc) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aSourceBc = *maybe__aSourceBc;
// Sentinel = 'aSourceBc'
if ((!(((&(reader__)))->ReadSentinel(296551288)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aTargetBc = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aTargetBc) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aTargetBc = *maybe__aTargetBc;
// Sentinel = 'aTargetBc'
if ((!(((&(reader__)))->ReadSentinel(289342318)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aPrintData = IPC::ReadParam<PrintData>((&(reader__)));
if (!maybe__aPrintData) {
FatalError("Error deserializing 'PrintData'");
return MsgValueError;
}
auto& aPrintData = *maybe__aPrintData;
// Sentinel = 'aPrintData'
if ((!(((&(reader__)))->ReadSentinel(359072745)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PrintData'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvCloneDocumentTreeInto(std::move(aSourceBc), std::move(aTargetBc), std::move(aPrintData));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UpdateRemotePrintSettings__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateRemotePrintSettings", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aBc = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aBc) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aBc = *maybe__aBc;
// Sentinel = 'aBc'
if ((!(((&(reader__)))->ReadSentinel(34406663)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aPrintData = IPC::ReadParam<PrintData>((&(reader__)));
if (!maybe__aPrintData) {
FatalError("Error deserializing 'PrintData'");
return MsgValueError;
}
auto& aPrintData = *maybe__aPrintData;
// Sentinel = 'aPrintData'
if ((!(((&(reader__)))->ReadSentinel(359072745)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PrintData'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvUpdateRemotePrintSettings(std::move(aBc), std::move(aPrintData));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PExtensionsConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PExtensionsConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PExtensionsParent> actor = (static_cast<ContentParent*>(this))->AllocPExtensionsParent();
if (!actor) {
NS_WARNING("Cannot bind null PExtensionsParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PExtensionsParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPExtensionsConstructor(actor);
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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PWebBrowserPersistDocumentConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto maybe__aBrowser = IPC::ReadParam<PBrowserParent*>((&(reader__)));
if (!maybe__aBrowser) {
FatalError("Error deserializing 'PBrowser'");
return MsgValueError;
}
auto& aBrowser = *maybe__aBrowser;
// Sentinel = 'aBrowser'
if ((!(((&(reader__)))->ReadSentinel(237372230)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PBrowser'");
return MsgValueError;
}
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PWebBrowserPersistDocumentParent> actor = (static_cast<ContentParent*>(this))->AllocPWebBrowserPersistDocumentParent(aBrowser, aContext);
if (!actor) {
NS_WARNING("Cannot bind null PWebBrowserPersistDocumentParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PWebBrowserPersistDocumentParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RawMessage", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aMetadata = IPC::ReadParam<JSActorMessageMeta>((&(reader__)));
if (!maybe__aMetadata) {
FatalError("Error deserializing 'JSActorMessageMeta'");
return MsgValueError;
}
auto& aMetadata = *maybe__aMetadata;
// Sentinel = 'aMetadata'
if ((!(((&(reader__)))->ReadSentinel(288752515)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'JSActorMessageMeta'");
return MsgValueError;
}
auto maybe__aData = IPC::ReadParam<mozilla::Maybe<ClonedMessageData>>((&(reader__)));
if (!maybe__aData) {
FatalError("Error deserializing 'ClonedMessageData?'");
return MsgValueError;
}
auto& aData = *maybe__aData;
// Sentinel = 'aData'
if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData?'");
return MsgValueError;
}
auto maybe__aStack = IPC::ReadParam<mozilla::Maybe<ClonedMessageData>>((&(reader__)));
if (!maybe__aStack) {
FatalError("Error deserializing 'ClonedMessageData?'");
return MsgValueError;
}
auto& aStack = *maybe__aStack;
// Sentinel = 'aStack'
if ((!(((&(reader__)))->ReadSentinel(135201368)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvRawMessage(std::move(aMetadata), std::move(aData), std::move(aStack));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Reply_RequestMemoryReport__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RequestMemoryReport", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<uint32_t> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__aGeneration = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aGeneration) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aGeneration = *maybe__aGeneration;
// Sentinel = 'aGeneration'
if ((!(((&(reader__)))->ReadSentinel(430179438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(aGeneration));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_PCycleCollectWithLogsConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_PTestShellConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_PScriptCacheConstructor__ID:
{
return MsgProcessed;
}
case PContent::Reply_CollectPerfStatsJSON__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CollectPerfStatsJSON", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<nsCString> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__aStats = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aStats) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aStats = *maybe__aStats;
// Sentinel = 'aStats'
if ((!(((&(reader__)))->ReadSentinel(137953905)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(aStats));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_CollectScrollingMetrics__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CollectScrollingMetrics", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<std::tuple<uint32_t, uint32_t>> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__pixelsScrolled = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__pixelsScrolled) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& pixelsScrolled = *maybe__pixelsScrolled;
// Sentinel = 'pixelsScrolled'
if ((!(((&(reader__)))->ReadSentinel(738395598)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__scrollDurationMS = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__scrollDurationMS) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& scrollDurationMS = *maybe__scrollDurationMS;
// Sentinel = 'scrollDurationMS'
if ((!(((&(reader__)))->ReadSentinel(945030774)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::make_tuple(std::move(pixelsScrolled), std::move(scrollDurationMS)));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_FlushCodeCoverageCounters__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FlushCodeCoverageCounters", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<bool> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__unused = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__unused) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& unused = *maybe__unused;
// Sentinel = 'unused'
if ((!(((&(reader__)))->ReadSentinel(155517589)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(unused));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_CrossProcessRedirect__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CrossProcessRedirect", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<nsresult> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__rv = IPC::ReadParam<nsresult>((&(reader__)));
if (!maybe__rv) {
FatalError("Error deserializing 'nsresult'");
return MsgValueError;
}
auto& rv = *maybe__rv;
// Sentinel = 'rv'
if ((!(((&(reader__)))->ReadSentinel(22806761)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(rv));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_LoadURI__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_LoadURI", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<bool> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__aSuccess = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aSuccess) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aSuccess = *maybe__aSuccess;
// Sentinel = 'aSuccess'
if ((!(((&(reader__)))->ReadSentinel(236323643)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(aSuccess));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_GetLayoutHistoryState__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetLayoutHistoryState", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<std::tuple<RefPtr<nsILayoutHistoryState>, mozilla::Maybe<Wireframe>>> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__aState = IPC::ReadParam<RefPtr<nsILayoutHistoryState>>((&(reader__)));
if (!maybe__aState) {
FatalError("Error deserializing 'nsILayoutHistoryState'");
return MsgValueError;
}
auto& aState = *maybe__aState;
// Sentinel = 'aState'
if ((!(((&(reader__)))->ReadSentinel(137036387)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsILayoutHistoryState'");
return MsgValueError;
}
auto maybe__aWireframe = IPC::ReadParam<mozilla::Maybe<Wireframe>>((&(reader__)));
if (!maybe__aWireframe) {
FatalError("Error deserializing 'Wireframe?'");
return MsgValueError;
}
auto& aWireframe = *maybe__aWireframe;
// Sentinel = 'aWireframe'
if ((!(((&(reader__)))->ReadSentinel(365888516)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Wireframe?'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::make_tuple(std::move(aState), std::move(aWireframe)));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_DispatchBeforeUnloadToSubtree__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_DispatchBeforeUnloadToSubtree", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<PermitUnloadResult> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__result = IPC::ReadParam<PermitUnloadResult>((&(reader__)));
if (!maybe__result) {
FatalError("Error deserializing 'PermitUnloadResult'");
return MsgValueError;
}
auto& result = *maybe__result;
// Sentinel = 'result'
if ((!(((&(reader__)))->ReadSentinel(153223840)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PermitUnloadResult'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(result));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Reply_PRemotePrintJobConstructor__ID:
{
return MsgProcessed;
}
case PContent::Msg_SynchronizeLayoutHistoryState__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SynchronizeLayoutHistoryState", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aState = IPC::ReadParam<RefPtr<nsILayoutHistoryState>>((&(reader__)));
if (!maybe__aState) {
FatalError("Error deserializing 'nsILayoutHistoryState'");
return MsgValueError;
}
auto& aState = *maybe__aState;
// Sentinel = 'aState'
if ((!(((&(reader__)))->ReadSentinel(137036387)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsILayoutHistoryState'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSynchronizeLayoutHistoryState(std::move(aContext), aState);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SessionHistoryEntryTitle__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryTitle", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aTitle = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aTitle) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aTitle = *maybe__aTitle;
// Sentinel = 'aTitle'
if ((!(((&(reader__)))->ReadSentinel(137167460)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSessionHistoryEntryTitle(std::move(aContext), std::move(aTitle));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SessionHistoryEntryScrollRestorationIsManual__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryScrollRestorationIsManual", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aIsManual = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aIsManual) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aIsManual = *maybe__aIsManual;
// Sentinel = 'aIsManual'
if ((!(((&(reader__)))->ReadSentinel(282526588)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSessionHistoryEntryScrollRestorationIsManual(std::move(aContext), std::move(aIsManual));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SessionHistoryEntryScrollPosition__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryScrollPosition", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aX = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aX) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aX = *maybe__aX;
// Sentinel = 'aX'
if ((!(((&(reader__)))->ReadSentinel(18612410)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto maybe__aY = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aY) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aY = *maybe__aY;
// Sentinel = 'aY'
if ((!(((&(reader__)))->ReadSentinel(18677947)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSessionHistoryEntryScrollPosition(std::move(aContext), std::move(aX), std::move(aY));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SessionHistoryEntryCacheKey__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryCacheKey", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aCacheKey = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aCacheKey) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aCacheKey = *maybe__aCacheKey;
// Sentinel = 'aCacheKey'
if ((!(((&(reader__)))->ReadSentinel(272827231)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSessionHistoryEntryCacheKey(std::move(aContext), std::move(aCacheKey));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SessionHistoryEntryStoreWindowNameInContiguousEntries__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryStoreWindowNameInContiguousEntries", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aName = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aName) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aName = *maybe__aName;
// Sentinel = 'aName'
if ((!(((&(reader__)))->ReadSentinel(92537315)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSessionHistoryEntryStoreWindowNameInContiguousEntries(std::move(aContext), std::move(aName));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SessionHistoryEntryWireframe__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryWireframe", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aWireframe = IPC::ReadParam<Wireframe>((&(reader__)));
if (!maybe__aWireframe) {
FatalError("Error deserializing 'Wireframe'");
return MsgValueError;
}
auto& aWireframe = *maybe__aWireframe;
// Sentinel = 'aWireframe'
if ((!(((&(reader__)))->ReadSentinel(365888516)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Wireframe'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSessionHistoryEntryWireframe(std::move(aContext), std::move(aWireframe));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_GetLoadingSessionHistoryInfoFromParent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetLoadingSessionHistoryInfoFromParent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_GetLoadingSessionHistoryInfoFromParent(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
GetLoadingSessionHistoryInfoFromParentResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<LoadingSessionHistoryInfo>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'aLoadingInfo'
((&(writer__)))->WriteSentinel(500827308);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvGetLoadingSessionHistoryInfoFromParent(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_RemoveFromBFCache__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RemoveFromBFCache", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvRemoveFromBFCache(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_InitBackground__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitBackground", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEndpoint = IPC::ReadParam<Endpoint<::mozilla::ipc::PBackgroundStarterParent>>((&(reader__)));
if (!maybe__aEndpoint) {
FatalError("Error deserializing 'Endpoint<::mozilla::ipc::PBackgroundStarterParent>'");
return MsgValueError;
}
auto& aEndpoint = *maybe__aEndpoint;
// Sentinel = 'aEndpoint'
if ((!(((&(reader__)))->ReadSentinel(292225955)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::ipc::PBackgroundStarterParent>'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvInitBackground(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_CreateGMPService__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateGMPService", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvCreateGMPService();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CreateClipboardContentAnalysis__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateClipboardContentAnalysis", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aParentEndpoint = IPC::ReadParam<Endpoint<::mozilla::PClipboardContentAnalysisParent>>((&(reader__)));
if (!maybe__aParentEndpoint) {
FatalError("Error deserializing 'Endpoint<::mozilla::PClipboardContentAnalysisParent>'");
return MsgValueError;
}
auto& aParentEndpoint = *maybe__aParentEndpoint;
// Sentinel = 'aParentEndpoint'
if ((!(((&(reader__)))->ReadSentinel(789775885)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PClipboardContentAnalysisParent>'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvCreateClipboardContentAnalysis(std::move(aParentEndpoint));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_InitStreamFilter__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitStreamFilter", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__channelId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__channelId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& channelId = *maybe__channelId;
// Sentinel = 'channelId'
if ((!(((&(reader__)))->ReadSentinel(301138823)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__addonId = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__addonId) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& addonId = *maybe__addonId;
// Sentinel = 'addonId'
if ((!(((&(reader__)))->ReadSentinel(183894708)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_InitStreamFilter(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
InitStreamFilterResolver resolver = [resolver__ = std::move(resolver__)](Endpoint<::mozilla::extensions::PStreamFilterChild>&& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), std::move(aParam));
// Sentinel = 'aEndpoint'
((&(writer__)))->WriteSentinel(292225955);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvInitStreamFilter(std::move(channelId), std::move(addonId), 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_PRemoteSpellcheckEngineConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PRemoteSpellcheckEngineConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
PRemoteSpellcheckEngineParent* actor = (static_cast<ContentParent*>(this))->AllocPRemoteSpellcheckEngineParent();
if (!actor) {
NS_WARNING("Cannot bind null PRemoteSpellcheckEngineParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PRemoteSpellcheckEngineParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPRemoteSpellcheckEngineConstructor(std::move(actor));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_InitCrashReporter__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitCrashReporter", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__tid = IPC::ReadParam<NativeThreadId>((&(reader__)));
if (!maybe__tid) {
FatalError("Error deserializing 'NativeThreadId'");
return MsgValueError;
}
auto& tid = *maybe__tid;
// Sentinel = 'tid'
if ((!(((&(reader__)))->ReadSentinel(43319618)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NativeThreadId'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvInitCrashReporter(std::move(tid));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AccumulateMixedContentHSTS__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AccumulateMixedContentHSTS", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aURI = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__aURI) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& aURI = *maybe__aURI;
// Sentinel = 'aURI'
if ((!(((&(reader__)))->ReadSentinel(57934162)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__aActive = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aActive) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aActive = *maybe__aActive;
// Sentinel = 'aActive'
if ((!(((&(reader__)))->ReadSentinel(176095934)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aOriginAttributes = IPC::ReadParam<OriginAttributes>((&(reader__)));
if (!maybe__aOriginAttributes) {
FatalError("Error deserializing 'OriginAttributes'");
return MsgValueError;
}
auto& aOriginAttributes = *maybe__aOriginAttributes;
// Sentinel = 'aOriginAttributes'
if ((!(((&(reader__)))->ReadSentinel(1021839089)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributes'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvAccumulateMixedContentHSTS(aURI, std::move(aActive), std::move(aOriginAttributes));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PHalConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PHalConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
PHalParent* actor = (static_cast<ContentParent*>(this))->AllocPHalParent();
if (!actor) {
NS_WARNING("Cannot bind null PHalParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PHalParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPHalConstructor(std::move(actor));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PHeapSnapshotTempFileHelperConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PHeapSnapshotTempFileHelperConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
PHeapSnapshotTempFileHelperParent* actor = (static_cast<ContentParent*>(this))->AllocPHeapSnapshotTempFileHelperParent();
if (!actor) {
NS_WARNING("Cannot bind null PHeapSnapshotTempFileHelperParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PHeapSnapshotTempFileHelperParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPHeapSnapshotTempFileHelperConstructor(std::move(actor));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PNeckoConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PNeckoConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PNeckoParent> actor = (static_cast<ContentParent*>(this))->AllocPNeckoParent();
if (!actor) {
NS_WARNING("Cannot bind null PNeckoParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PNeckoParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPNeckoConstructor(actor);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PSpeechSynthesisConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PSpeechSynthesisConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PSpeechSynthesisParent> actor = (static_cast<ContentParent*>(this))->AllocPSpeechSynthesisParent();
if (!actor) {
NS_WARNING("Cannot bind null PSpeechSynthesisParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PSpeechSynthesisParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPSpeechSynthesisConstructor(actor);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PMediaConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PMediaConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
PMediaParent* actor = (static_cast<ContentParent*>(this))->AllocPMediaParent();
if (!actor) {
NS_WARNING("Cannot bind null PMediaParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PMediaParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPMediaConstructor(std::move(actor));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PWebrtcGlobalConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PWebrtcGlobalConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
PWebrtcGlobalParent* actor = (static_cast<ContentParent*>(this))->AllocPWebrtcGlobalParent();
if (!actor) {
NS_WARNING("Cannot bind null PWebrtcGlobalParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PWebrtcGlobalParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPWebrtcGlobalConstructor(std::move(actor));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CreateAudioIPCConnection__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateAudioIPCConnection", OTHER);
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_CreateAudioIPCConnection(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
CreateAudioIPCConnectionResolver resolver = [resolver__ = std::move(resolver__)](const FileDescOrError& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'fd'
((&(writer__)))->WriteSentinel(20054219);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvCreateAudioIPCConnection(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_PURLClassifierLocalConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PURLClassifierLocalConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto maybe__uri = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__uri) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& uri = *maybe__uri;
// Sentinel = 'uri'
if ((!(((&(reader__)))->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__features = IPC::ReadParam<nsTArray<IPCURLClassifierFeature>>((&(reader__)));
if (!maybe__features) {
FatalError("Error deserializing 'IPCURLClassifierFeature[]'");
return MsgValueError;
}
auto& features = *maybe__features;
// Sentinel = 'features'
if ((!(((&(reader__)))->ReadSentinel(250348384)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCURLClassifierFeature[]'");
return MsgValueError;
}
reader__.EndRead();
PURLClassifierLocalParent* actor = (static_cast<ContentParent*>(this))->AllocPURLClassifierLocalParent(uri, features);
if (!actor) {
NS_WARNING("Cannot bind null PURLClassifierLocalParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PURLClassifierLocalParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPURLClassifierLocalConstructor(std::move(actor), uri, std::move(features));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PSessionStorageObserverConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PSessionStorageObserverConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
PSessionStorageObserverParent* actor = (static_cast<ContentParent*>(this))->AllocPSessionStorageObserverParent();
if (!actor) {
NS_WARNING("Cannot bind null PSessionStorageObserverParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PSessionStorageObserverParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPSessionStorageObserverConstructor(std::move(actor));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PBenchmarkStorageConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PBenchmarkStorageConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
PBenchmarkStorageParent* actor = (static_cast<ContentParent*>(this))->AllocPBenchmarkStorageParent();
if (!actor) {
NS_WARNING("Cannot bind null PBenchmarkStorageParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PBenchmarkStorageParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPBenchmarkStorageConstructor(std::move(actor));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_StartVisitedQueries__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_StartVisitedQueries", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__uri = IPC::ReadParam<nsTArray<RefPtr<nsIURI>>>((&(reader__)));
if (!maybe__uri) {
FatalError("Error deserializing 'nsIURI[]'");
return MsgValueError;
}
auto& uri = *maybe__uri;
// Sentinel = 'uri'
if ((!(((&(reader__)))->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvStartVisitedQueries(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_SetURITitle__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetURITitle", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__uri = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__uri) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& uri = *maybe__uri;
// Sentinel = 'uri'
if ((!(((&(reader__)))->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__title = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__title) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& title = *maybe__title;
// Sentinel = 'title'
if ((!(((&(reader__)))->ReadSentinel(109445667)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSetURITitle(uri, std::move(title));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_LoadURIExternal__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_LoadURIExternal", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__uri = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__uri) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& uri = *maybe__uri;
// Sentinel = 'uri'
if ((!(((&(reader__)))->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__triggeringPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__triggeringPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& triggeringPrincipal = *maybe__triggeringPrincipal;
// Sentinel = 'triggeringPrincipal'
if ((!(((&(reader__)))->ReadSentinel(1325729749)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__redirectPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__redirectPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& redirectPrincipal = *maybe__redirectPrincipal;
// Sentinel = 'redirectPrincipal'
if ((!(((&(reader__)))->ReadSentinel(1052772085)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__browsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__browsingContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& browsingContext = *maybe__browsingContext;
// Sentinel = 'browsingContext'
if ((!(((&(reader__)))->ReadSentinel(844695121)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__wasExternallyTriggered = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__wasExternallyTriggered) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& wasExternallyTriggered = *maybe__wasExternallyTriggered;
// Sentinel = 'wasExternallyTriggered'
if ((!(((&(reader__)))->ReadSentinel(1758005521)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__hasValidUserGestureActivation = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__hasValidUserGestureActivation) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& hasValidUserGestureActivation = *maybe__hasValidUserGestureActivation;
// Sentinel = 'hasValidUserGestureActivation'
if ((!(((&(reader__)))->ReadSentinel(2914388925)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__newWindowTarget = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__newWindowTarget) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& newWindowTarget = *maybe__newWindowTarget;
// Sentinel = 'newWindowTarget'
if ((!(((&(reader__)))->ReadSentinel(826934826)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvLoadURIExternal(uri, triggeringPrincipal, redirectPrincipal, std::move(browsingContext), std::move(wasExternallyTriggered), std::move(hasValidUserGestureActivation), std::move(newWindowTarget));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ExtProtocolChannelConnectParent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ExtProtocolChannelConnectParent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__registrarId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__registrarId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& registrarId = *maybe__registrarId;
// Sentinel = 'registrarId'
if ((!(((&(reader__)))->ReadSentinel(464585857)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvExtProtocolChannelConnectParent(std::move(registrarId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ShowAlert__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ShowAlert", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__alert = IPC::ReadParam<RefPtr<nsIAlertNotification>>((&(reader__)));
if (!maybe__alert) {
FatalError("Error deserializing 'nsIAlertNotification'");
return MsgValueError;
}
auto& alert = *maybe__alert;
// Sentinel = 'alert'
if ((!(((&(reader__)))->ReadSentinel(102826521)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIAlertNotification'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvShowAlert(alert);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CloseAlert__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CloseAlert", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__name = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__name) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& name = *maybe__name;
// Sentinel = 'name'
if ((!(((&(reader__)))->ReadSentinel(69075362)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__contextClosed = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__contextClosed) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& contextClosed = *maybe__contextClosed;
// Sentinel = 'contextClosed'
if ((!(((&(reader__)))->ReadSentinel(636749152)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvCloseAlert(std::move(name), std::move(contextClosed));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_DisableNotifications__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_DisableNotifications", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__principal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__principal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& principal = *maybe__principal;
// Sentinel = 'principal'
if ((!(((&(reader__)))->ReadSentinel(319620035)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvDisableNotifications(principal);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_OpenNotificationSettings__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_OpenNotificationSettings", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__principal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__principal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& principal = *maybe__principal;
// Sentinel = 'principal'
if ((!(((&(reader__)))->ReadSentinel(319620035)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvOpenNotificationSettings(principal);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AddSecurityState__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddSecurityState", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto maybe__aStateFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aStateFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aStateFlags = *maybe__aStateFlags;
// Sentinel = 'aStateFlags'
if ((!(((&(reader__)))->ReadSentinel(428606544)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvAddSecurityState(std::move(aContext), std::move(aStateFlags));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotificationEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotificationEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__type = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__type) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& type = *maybe__type;
// Sentinel = 'type'
if ((!(((&(reader__)))->ReadSentinel(75760067)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__data = IPC::ReadParam<NotificationEventData>((&(reader__)));
if (!maybe__data) {
FatalError("Error deserializing 'NotificationEventData'");
return MsgValueError;
}
auto& data = *maybe__data;
// Sentinel = 'data'
if ((!(((&(reader__)))->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotificationEventData'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotificationEvent(std::move(type), std::move(data));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PExternalHelperAppConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PExternalHelperAppConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto maybe__uri = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__uri) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& uri = *maybe__uri;
// Sentinel = 'uri'
if ((!(((&(reader__)))->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__loadInfoArgs = IPC::ReadParam<LoadInfoArgs>((&(reader__)));
if (!maybe__loadInfoArgs) {
FatalError("Error deserializing 'LoadInfoArgs'");
return MsgValueError;
}
auto& loadInfoArgs = *maybe__loadInfoArgs;
// Sentinel = 'loadInfoArgs'
if ((!(((&(reader__)))->ReadSentinel(514000058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LoadInfoArgs'");
return MsgValueError;
}
auto maybe__aMimeContentType = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aMimeContentType) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aMimeContentType = *maybe__aMimeContentType;
// Sentinel = 'aMimeContentType'
if ((!(((&(reader__)))->ReadSentinel(888538727)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aContentDisposition = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aContentDisposition) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aContentDisposition = *maybe__aContentDisposition;
// Sentinel = 'aContentDisposition'
if ((!(((&(reader__)))->ReadSentinel(1279461330)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aContentDispositionHint = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aContentDispositionHint) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aContentDispositionHint = *maybe__aContentDispositionHint;
// Sentinel = 'aContentDispositionHint'
if ((!(((&(reader__)))->ReadSentinel(1865812325)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aContentDispositionFilename = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aContentDispositionFilename) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aContentDispositionFilename = *maybe__aContentDispositionFilename;
// Sentinel = 'aContentDispositionFilename'
if ((!(((&(reader__)))->ReadSentinel(2558331635)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aForceSave = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aForceSave) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aForceSave = *maybe__aForceSave;
// Sentinel = 'aForceSave'
if ((!(((&(reader__)))->ReadSentinel(350946272)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aContentLength = IPC::ReadParam<int64_t>((&(reader__)));
if (!maybe__aContentLength) {
FatalError("Error deserializing 'int64_t'");
return MsgValueError;
}
auto& aContentLength = *maybe__aContentLength;
// Sentinel = 'aContentLength'
if ((!(((&(reader__)))->ReadSentinel(694158751)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int64_t'");
return MsgValueError;
}
auto maybe__aWasFileChannel = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aWasFileChannel) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aWasFileChannel = *maybe__aWasFileChannel;
// Sentinel = 'aWasFileChannel'
if ((!(((&(reader__)))->ReadSentinel(759367110)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aReferrer = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__aReferrer) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& aReferrer = *maybe__aReferrer;
// Sentinel = 'aReferrer'
if ((!(((&(reader__)))->ReadSentinel(293340063)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PExternalHelperAppParent> actor = (static_cast<ContentParent*>(this))->AllocPExternalHelperAppParent(uri, loadInfoArgs, aMimeContentType, aContentDisposition, aContentDispositionHint, aContentDispositionFilename, aForceSave, aContentLength, aWasFileChannel, aReferrer, aContext);
if (!actor) {
NS_WARNING("Cannot bind null PExternalHelperAppParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PExternalHelperAppParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPExternalHelperAppConstructor(actor, uri, std::move(loadInfoArgs), std::move(aMimeContentType), std::move(aContentDisposition), std::move(aContentDispositionHint), std::move(aContentDispositionFilename), std::move(aForceSave), std::move(aContentLength), std::move(aWasFileChannel), aReferrer, 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_PHandlerServiceConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PHandlerServiceConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PHandlerServiceParent> actor = (static_cast<ContentParent*>(this))->AllocPHandlerServiceParent();
if (!actor) {
NS_WARNING("Cannot bind null PHandlerServiceParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PHandlerServiceParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPHandlerServiceConstructor(actor);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AddGeolocationListener__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddGeolocationListener", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__highAccuracy = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__highAccuracy) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& highAccuracy = *maybe__highAccuracy;
// Sentinel = 'highAccuracy'
if ((!(((&(reader__)))->ReadSentinel(513737932)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvAddGeolocationListener(std::move(highAccuracy));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RemoveGeolocationListener__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RemoveGeolocationListener", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvRemoveGeolocationListener();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetGeolocationHigherAccuracy__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetGeolocationHigherAccuracy", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__enable = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__enable) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& enable = *maybe__enable;
// Sentinel = 'enable'
if ((!(((&(reader__)))->ReadSentinel(141623912)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSetGeolocationHigherAccuracy(std::move(enable));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ConsoleMessage__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ConsoleMessage", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__message = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__message) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& message = *maybe__message;
// Sentinel = 'message'
if ((!(((&(reader__)))->ReadSentinel(197198566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvConsoleMessage(std::move(message));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ScriptErrorWithStack__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ScriptErrorWithStack", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__message = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__message) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& message = *maybe__message;
// Sentinel = 'message'
if ((!(((&(reader__)))->ReadSentinel(197198566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__sourceName = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__sourceName) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& sourceName = *maybe__sourceName;
// Sentinel = 'sourceName'
if ((!(((&(reader__)))->ReadSentinel(387580947)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__lineNumber = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__lineNumber) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& lineNumber = *maybe__lineNumber;
// Sentinel = 'lineNumber'
if ((!(((&(reader__)))->ReadSentinel(374932498)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__colNumber = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__colNumber) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& colNumber = *maybe__colNumber;
// Sentinel = 'colNumber'
if ((!(((&(reader__)))->ReadSentinel(304284584)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__flags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__flags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& flags = *maybe__flags;
// Sentinel = 'flags'
if ((!(((&(reader__)))->ReadSentinel(102171150)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__category = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__category) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& category = *maybe__category;
// Sentinel = 'category'
if ((!(((&(reader__)))->ReadSentinel(247333727)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__isFromPrivateWindow = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__isFromPrivateWindow) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& isFromPrivateWindow = *maybe__isFromPrivateWindow;
// Sentinel = 'isFromPrivateWindow'
if ((!(((&(reader__)))->ReadSentinel(1288964036)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__isFromChromeContext = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__isFromChromeContext) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& isFromChromeContext = *maybe__isFromChromeContext;
// Sentinel = 'isFromChromeContext'
if ((!(((&(reader__)))->ReadSentinel(1269368756)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__stack = IPC::ReadParam<ClonedMessageData>((&(reader__)));
if (!maybe__stack) {
FatalError("Error deserializing 'ClonedMessageData'");
return MsgValueError;
}
auto& stack = *maybe__stack;
// Sentinel = 'stack'
if ((!(((&(reader__)))->ReadSentinel(107479575)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvScriptErrorWithStack(std::move(message), std::move(sourceName), std::move(lineNumber), std::move(colNumber), std::move(flags), std::move(category), std::move(isFromPrivateWindow), std::move(isFromChromeContext), std::move(stack));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetClipboard__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetClipboard", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aTransferable = IPC::ReadParam<IPCTransferable>((&(reader__)));
if (!maybe__aTransferable) {
FatalError("Error deserializing 'IPCTransferable'");
return MsgValueError;
}
auto& aTransferable = *maybe__aTransferable;
// Sentinel = 'aTransferable'
if ((!(((&(reader__)))->ReadSentinel(609813819)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCTransferable'");
return MsgValueError;
}
auto maybe__aWhichClipboard = IPC::ReadParam<ClipboardType>((&(reader__)));
if (!maybe__aWhichClipboard) {
FatalError("Error deserializing 'ClipboardType'");
return MsgValueError;
}
auto& aWhichClipboard = *maybe__aWhichClipboard;
// Sentinel = 'aWhichClipboard'
if ((!(((&(reader__)))->ReadSentinel(776996325)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
return MsgValueError;
}
auto maybe__aRequestingWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
if (!maybe__aRequestingWindowContext) {
FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto& aRequestingWindowContext = *maybe__aRequestingWindowContext;
// Sentinel = 'aRequestingWindowContext'
if ((!(((&(reader__)))->ReadSentinel(2049051110)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSetClipboard(std::move(aTransferable), std::move(aWhichClipboard), std::move(aRequestingWindowContext));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_GetClipboardDataSnapshot__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetClipboardDataSnapshot", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aTypes = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
if (!maybe__aTypes) {
FatalError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto& aTypes = *maybe__aTypes;
// Sentinel = 'aTypes'
if ((!(((&(reader__)))->ReadSentinel(140575351)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto maybe__aWhichClipboard = IPC::ReadParam<ClipboardType>((&(reader__)));
if (!maybe__aWhichClipboard) {
FatalError("Error deserializing 'ClipboardType'");
return MsgValueError;
}
auto& aWhichClipboard = *maybe__aWhichClipboard;
// Sentinel = 'aWhichClipboard'
if ((!(((&(reader__)))->ReadSentinel(776996325)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
return MsgValueError;
}
auto maybe__aRequestingWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
if (!maybe__aRequestingWindowContext) {
FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto& aRequestingWindowContext = *maybe__aRequestingWindowContext;
// Sentinel = 'aRequestingWindowContext'
if ((!(((&(reader__)))->ReadSentinel(2049051110)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto maybe__aRequestingPrincipal = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIPrincipal>>>((&(reader__)));
if (!maybe__aRequestingPrincipal) {
FatalError("Error deserializing 'NotNull<nsIPrincipal>'");
return MsgValueError;
}
auto& aRequestingPrincipal = *maybe__aRequestingPrincipal;
// Sentinel = 'aRequestingPrincipal'
if ((!(((&(reader__)))->ReadSentinel(1431439403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIPrincipal>'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_GetClipboardDataSnapshot(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
GetClipboardDataSnapshotResolver resolver = [resolver__ = std::move(resolver__)](ClipboardReadRequestOrError&& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), std::move(aParam));
// Sentinel = 'aClipboardReadRequestOrError'
((&(writer__)))->WriteSentinel(2662402850);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvGetClipboardDataSnapshot(std::move(aTypes), std::move(aWhichClipboard), std::move(aRequestingWindowContext), aRequestingPrincipal, 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_EmptyClipboard__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_EmptyClipboard", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aWhichClipboard = IPC::ReadParam<ClipboardType>((&(reader__)));
if (!maybe__aWhichClipboard) {
FatalError("Error deserializing 'ClipboardType'");
return MsgValueError;
}
auto& aWhichClipboard = *maybe__aWhichClipboard;
// Sentinel = 'aWhichClipboard'
if ((!(((&(reader__)))->ReadSentinel(776996325)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvEmptyClipboard(std::move(aWhichClipboard));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PClipboardWriteRequestConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PClipboardWriteRequestConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto maybe__aClipboardType = IPC::ReadParam<ClipboardType>((&(reader__)));
if (!maybe__aClipboardType) {
FatalError("Error deserializing 'ClipboardType'");
return MsgValueError;
}
auto& aClipboardType = *maybe__aClipboardType;
// Sentinel = 'aClipboardType'
if ((!(((&(reader__)))->ReadSentinel(686228884)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
return MsgValueError;
}
auto maybe__aSettingWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
if (!maybe__aSettingWindowContext) {
FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto& aSettingWindowContext = *maybe__aSettingWindowContext;
// Sentinel = 'aSettingWindowContext'
if ((!(((&(reader__)))->ReadSentinel(1561659549)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PClipboardWriteRequestParent> actor = (static_cast<ContentParent*>(this))->AllocPClipboardWriteRequestParent(aClipboardType, aSettingWindowContext);
if (!actor) {
NS_WARNING("Cannot bind null PClipboardWriteRequestParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PClipboardWriteRequestParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPClipboardWriteRequestConstructor(actor, std::move(aClipboardType), std::move(aSettingWindowContext));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_FirstIdle__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FirstIdle", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvFirstIdle();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CopyFavicon__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CopyFavicon", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__oldURI = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__oldURI) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& oldURI = *maybe__oldURI;
// Sentinel = 'oldURI'
if ((!(((&(reader__)))->ReadSentinel(137888304)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__newURI = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__newURI) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& newURI = *maybe__newURI;
// Sentinel = 'newURI'
if ((!(((&(reader__)))->ReadSentinel(140182075)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__isPrivate = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__isPrivate) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& isPrivate = *maybe__isPrivate;
// Sentinel = 'isPrivate'
if ((!(((&(reader__)))->ReadSentinel(310576056)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvCopyFavicon(oldURI, newURI, std::move(isPrivate));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_FindImageText__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FindImageText", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__image = IPC::ReadParam<IPCImage>((&(reader__)));
if (!maybe__image) {
FatalError("Error deserializing 'IPCImage'");
return MsgValueError;
}
auto& image = *maybe__image;
// Sentinel = 'image'
if ((!(((&(reader__)))->ReadSentinel(102498820)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCImage'");
return MsgValueError;
}
auto maybe__languages = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
if (!maybe__languages) {
FatalError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto& languages = *maybe__languages;
// Sentinel = 'languages'
if ((!(((&(reader__)))->ReadSentinel(310903736)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_FindImageText(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
FindImageTextResolver resolver = [resolver__ = std::move(resolver__)](const TextRecognitionResultOrError& 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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvFindImageText(std::move(image), std::move(languages), 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_GraphicsError__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GraphicsError", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aError = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aError) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aError = *maybe__aError;
// Sentinel = 'aError'
if ((!(((&(reader__)))->ReadSentinel(135463532)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvGraphicsError(std::move(aError));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AddIdleObserver__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddIdleObserver", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__observerId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__observerId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& observerId = *maybe__observerId;
// Sentinel = 'observerId'
if ((!(((&(reader__)))->ReadSentinel(386335766)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__idleTimeInS = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__idleTimeInS) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& idleTimeInS = *maybe__idleTimeInS;
// Sentinel = 'idleTimeInS'
if ((!(((&(reader__)))->ReadSentinel(434832440)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvAddIdleObserver(std::move(observerId), std::move(idleTimeInS));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RemoveIdleObserver__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RemoveIdleObserver", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__observerId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__observerId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& observerId = *maybe__observerId;
// Sentinel = 'observerId'
if ((!(((&(reader__)))->ReadSentinel(386335766)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__idleTimeInS = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__idleTimeInS) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& idleTimeInS = *maybe__idleTimeInS;
// Sentinel = 'idleTimeInS'
if ((!(((&(reader__)))->ReadSentinel(434832440)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvRemoveIdleObserver(std::move(observerId), std::move(idleTimeInS));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_BackUpXResources__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_BackUpXResources", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aXSocketFd = IPC::ReadParam<FileDescriptor>((&(reader__)));
if (!maybe__aXSocketFd) {
FatalError("Error deserializing 'FileDescriptor'");
return MsgValueError;
}
auto& aXSocketFd = *maybe__aXSocketFd;
// Sentinel = 'aXSocketFd'
if ((!(((&(reader__)))->ReadSentinel(349569997)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvBackUpXResources(std::move(aXSocketFd));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RequestAnonymousTemporaryFile__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RequestAnonymousTemporaryFile", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aID = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aID) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aID = *maybe__aID;
// Sentinel = 'aID'
if ((!(((&(reader__)))->ReadSentinel(33292527)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvRequestAnonymousTemporaryFile(std::move(aID));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyShutdownSuccess__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyShutdownSuccess", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyShutdownSuccess();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_FinishShutdown__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FinishShutdown", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvFinishShutdown();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PContentPermissionRequestConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PContentPermissionRequestConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto maybe__aRequests = IPC::ReadParam<nsTArray<PermissionRequest>>((&(reader__)));
if (!maybe__aRequests) {
FatalError("Error deserializing 'PermissionRequest[]'");
return MsgValueError;
}
auto& aRequests = *maybe__aRequests;
// Sentinel = 'aRequests'
if ((!(((&(reader__)))->ReadSentinel(301728702)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PermissionRequest[]'");
return MsgValueError;
}
auto maybe__aPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aPrincipal = *maybe__aPrincipal;
// Sentinel = 'aPrincipal'
if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__aTopLevelPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aTopLevelPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aTopLevelPrincipal = *maybe__aTopLevelPrincipal;
// Sentinel = 'aTopLevelPrincipal'
if ((!(((&(reader__)))->ReadSentinel(1128007471)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__aIsHandlingUserInput = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aIsHandlingUserInput) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aIsHandlingUserInput = *maybe__aIsHandlingUserInput;
// Sentinel = 'aIsHandlingUserInput'
if ((!(((&(reader__)))->ReadSentinel(1357514738)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aMaybeUnsafePermissionDelegate = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aMaybeUnsafePermissionDelegate) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aMaybeUnsafePermissionDelegate = *maybe__aMaybeUnsafePermissionDelegate;
// Sentinel = 'aMaybeUnsafePermissionDelegate'
if ((!(((&(reader__)))->ReadSentinel(3078949878)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__tabId = IPC::ReadParam<TabId>((&(reader__)));
if (!maybe__tabId) {
FatalError("Error deserializing 'TabId'");
return MsgValueError;
}
auto& tabId = *maybe__tabId;
// Sentinel = 'tabId'
if ((!(((&(reader__)))->ReadSentinel(99156453)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
return MsgValueError;
}
reader__.EndRead();
PContentPermissionRequestParent* actor = (static_cast<ContentParent*>(this))->AllocPContentPermissionRequestParent(aRequests, aPrincipal, aTopLevelPrincipal, aIsHandlingUserInput, aMaybeUnsafePermissionDelegate, tabId);
if (!actor) {
NS_WARNING("Cannot bind null PContentPermissionRequestParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PContentPermissionRequestParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPContentPermissionRequestConstructor(std::move(actor), std::move(aRequests), aPrincipal, aTopLevelPrincipal, std::move(aIsHandlingUserInput), std::move(aMaybeUnsafePermissionDelegate), std::move(tabId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ShutdownProfile__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ShutdownProfile", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aProfile = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aProfile) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aProfile = *maybe__aProfile;
// Sentinel = 'aProfile'
if ((!(((&(reader__)))->ReadSentinel(237437747)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvShutdownProfile(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_ShutdownPerfStats__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ShutdownPerfStats", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPerfStats = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aPerfStats) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aPerfStats = *maybe__aPerfStats;
// Sentinel = 'aPerfStats'
if ((!(((&(reader__)))->ReadSentinel(356189182)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvShutdownPerfStats(std::move(aPerfStats));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetCharacterMap__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetCharacterMap", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aGeneration = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aGeneration) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aGeneration = *maybe__aGeneration;
// Sentinel = 'aGeneration'
if ((!(((&(reader__)))->ReadSentinel(430179438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aFamilyIndex = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aFamilyIndex) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aFamilyIndex = *maybe__aFamilyIndex;
// Sentinel = 'aFamilyIndex'
if ((!(((&(reader__)))->ReadSentinel(501089468)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aAlias = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aAlias) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aAlias = *maybe__aAlias;
// Sentinel = 'aAlias'
if ((!(((&(reader__)))->ReadSentinel(129040972)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aFaceIndex = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aFaceIndex) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aFaceIndex = *maybe__aFaceIndex;
// Sentinel = 'aFaceIndex'
if ((!(((&(reader__)))->ReadSentinel(335021001)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aMap = IPC::ReadParam<gfxSparseBitSet>((&(reader__)));
if (!maybe__aMap) {
FatalError("Error deserializing 'gfxSparseBitSet'");
return MsgValueError;
}
auto& aMap = *maybe__aMap;
// Sentinel = 'aMap'
if ((!(((&(reader__)))->ReadSentinel(60883328)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'gfxSparseBitSet'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSetCharacterMap(std::move(aGeneration), std::move(aFamilyIndex), std::move(aAlias), std::move(aFaceIndex), std::move(aMap));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_SetupFamilyCharMap__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetupFamilyCharMap", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aGeneration = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aGeneration) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aGeneration = *maybe__aGeneration;
// Sentinel = 'aGeneration'
if ((!(((&(reader__)))->ReadSentinel(430179438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aFamilyIndex = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aFamilyIndex) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aFamilyIndex = *maybe__aFamilyIndex;
// Sentinel = 'aFamilyIndex'
if ((!(((&(reader__)))->ReadSentinel(501089468)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aAlias = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aAlias) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aAlias = *maybe__aAlias;
// Sentinel = 'aAlias'
if ((!(((&(reader__)))->ReadSentinel(129040972)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSetupFamilyCharMap(std::move(aGeneration), std::move(aFamilyIndex), std::move(aAlias));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_StartCmapLoading__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_StartCmapLoading", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aGeneration = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aGeneration) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aGeneration = *maybe__aGeneration;
// Sentinel = 'aGeneration'
if ((!(((&(reader__)))->ReadSentinel(430179438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aStartIndex = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aStartIndex) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aStartIndex = *maybe__aStartIndex;
// Sentinel = 'aStartIndex'
if ((!(((&(reader__)))->ReadSentinel(435749992)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvStartCmapLoading(std::move(aGeneration), std::move(aStartIndex));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CreateWindow__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateWindow", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aThisTab = IPC::ReadParam<mozilla::NotNull<PBrowserParent*>>((&(reader__)));
if (!maybe__aThisTab) {
FatalError("Error deserializing 'NotNull<PBrowser>'");
return MsgValueError;
}
auto& aThisTab = *maybe__aThisTab;
// Sentinel = 'aThisTab'
if ((!(((&(reader__)))->ReadSentinel(231015185)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<PBrowser>'");
return MsgValueError;
}
auto maybe__aParent = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aParent) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aParent = *maybe__aParent;
// Sentinel = 'aParent'
if ((!(((&(reader__)))->ReadSentinel(179962572)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aNewTab = IPC::ReadParam<mozilla::NotNull<PBrowserParent*>>((&(reader__)));
if (!maybe__aNewTab) {
FatalError("Error deserializing 'NotNull<PBrowser>'");
return MsgValueError;
}
auto& aNewTab = *maybe__aNewTab;
// Sentinel = 'aNewTab'
if ((!(((&(reader__)))->ReadSentinel(175571619)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<PBrowser>'");
return MsgValueError;
}
auto maybe__aChromeFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aChromeFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aChromeFlags = *maybe__aChromeFlags;
// Sentinel = 'aChromeFlags'
if ((!(((&(reader__)))->ReadSentinel(500040877)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aCalledFromJS = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aCalledFromJS) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aCalledFromJS = *maybe__aCalledFromJS;
// Sentinel = 'aCalledFromJS'
if ((!(((&(reader__)))->ReadSentinel(569967832)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aForPrinting = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aForPrinting) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aForPrinting = *maybe__aForPrinting;
// Sentinel = 'aForPrinting'
if ((!(((&(reader__)))->ReadSentinel(511313108)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aForWindowDotPrint = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aForWindowDotPrint) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aForWindowDotPrint = *maybe__aForWindowDotPrint;
// Sentinel = 'aForWindowDotPrint'
if ((!(((&(reader__)))->ReadSentinel(1123813173)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aTopLevelCreatedByContent = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aTopLevelCreatedByContent) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aTopLevelCreatedByContent = *maybe__aTopLevelCreatedByContent;
// Sentinel = 'aTopLevelCreatedByContent'
if ((!(((&(reader__)))->ReadSentinel(2117143003)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aURIToLoad = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__aURIToLoad) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& aURIToLoad = *maybe__aURIToLoad;
// Sentinel = 'aURIToLoad'
if ((!(((&(reader__)))->ReadSentinel(321258389)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__aFeatures = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aFeatures) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aFeatures = *maybe__aFeatures;
// Sentinel = 'aFeatures'
if ((!(((&(reader__)))->ReadSentinel(290849697)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aModifiers = IPC::ReadParam<Modifiers>((&(reader__)));
if (!maybe__aModifiers) {
FatalError("Error deserializing 'Modifiers'");
return MsgValueError;
}
auto& aModifiers = *maybe__aModifiers;
// Sentinel = 'aModifiers'
if ((!(((&(reader__)))->ReadSentinel(358286340)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Modifiers'");
return MsgValueError;
}
auto maybe__aTriggeringPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aTriggeringPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aTriggeringPrincipal = *maybe__aTriggeringPrincipal;
// Sentinel = 'aTriggeringPrincipal'
if ((!(((&(reader__)))->ReadSentinel(1413089302)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__aCsp = IPC::ReadParam<RefPtr<nsIContentSecurityPolicy>>((&(reader__)));
if (!maybe__aCsp) {
FatalError("Error deserializing 'nsIContentSecurityPolicy'");
return MsgValueError;
}
auto& aCsp = *maybe__aCsp;
// Sentinel = 'aCsp'
if ((!(((&(reader__)))->ReadSentinel(61276552)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIContentSecurityPolicy'");
return MsgValueError;
}
auto maybe__aReferrerInfo = IPC::ReadParam<RefPtr<nsIReferrerInfo>>((&(reader__)));
if (!maybe__aReferrerInfo) {
FatalError("Error deserializing 'nsIReferrerInfo'");
return MsgValueError;
}
auto& aReferrerInfo = *maybe__aReferrerInfo;
// Sentinel = 'aReferrerInfo'
if ((!(((&(reader__)))->ReadSentinel(597755179)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIReferrerInfo'");
return MsgValueError;
}
auto maybe__aOriginAttributes = IPC::ReadParam<OriginAttributes>((&(reader__)));
if (!maybe__aOriginAttributes) {
FatalError("Error deserializing 'OriginAttributes'");
return MsgValueError;
}
auto& aOriginAttributes = *maybe__aOriginAttributes;
// Sentinel = 'aOriginAttributes'
if ((!(((&(reader__)))->ReadSentinel(1021839089)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributes'");
return MsgValueError;
}
auto maybe__aUserActivation = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aUserActivation) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aUserActivation = *maybe__aUserActivation;
// Sentinel = 'aUserActivation'
if ((!(((&(reader__)))->ReadSentinel(794887699)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aTextDirectiveUserActivation = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aTextDirectiveUserActivation) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aTextDirectiveUserActivation = *maybe__aTextDirectiveUserActivation;
// Sentinel = 'aTextDirectiveUserActivation'
if ((!(((&(reader__)))->ReadSentinel(2721450839)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_CreateWindow(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
CreateWindowResolver resolver = [resolver__ = std::move(resolver__)](const CreatedWindowInfo& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'window'
((&(writer__)))->WriteSentinel(152437401);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvCreateWindow(aThisTab, std::move(aParent), aNewTab, std::move(aChromeFlags), std::move(aCalledFromJS), std::move(aForPrinting), std::move(aForWindowDotPrint), std::move(aTopLevelCreatedByContent), aURIToLoad, std::move(aFeatures), std::move(aModifiers), aTriggeringPrincipal, aCsp, aReferrerInfo, std::move(aOriginAttributes), std::move(aUserActivation), std::move(aTextDirectiveUserActivation), 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_CreateWindowInDifferentProcess__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateWindowInDifferentProcess", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aThisTab = IPC::ReadParam<mozilla::NotNull<PBrowserParent*>>((&(reader__)));
if (!maybe__aThisTab) {
FatalError("Error deserializing 'NotNull<PBrowser>'");
return MsgValueError;
}
auto& aThisTab = *maybe__aThisTab;
// Sentinel = 'aThisTab'
if ((!(((&(reader__)))->ReadSentinel(231015185)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<PBrowser>'");
return MsgValueError;
}
auto maybe__aParent = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aParent) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aParent = *maybe__aParent;
// Sentinel = 'aParent'
if ((!(((&(reader__)))->ReadSentinel(179962572)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aChromeFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aChromeFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aChromeFlags = *maybe__aChromeFlags;
// Sentinel = 'aChromeFlags'
if ((!(((&(reader__)))->ReadSentinel(500040877)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aCalledFromJS = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aCalledFromJS) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aCalledFromJS = *maybe__aCalledFromJS;
// Sentinel = 'aCalledFromJS'
if ((!(((&(reader__)))->ReadSentinel(569967832)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aTopLevelCreatedByContent = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aTopLevelCreatedByContent) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aTopLevelCreatedByContent = *maybe__aTopLevelCreatedByContent;
// Sentinel = 'aTopLevelCreatedByContent'
if ((!(((&(reader__)))->ReadSentinel(2117143003)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aURIToLoad = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__aURIToLoad) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& aURIToLoad = *maybe__aURIToLoad;
// Sentinel = 'aURIToLoad'
if ((!(((&(reader__)))->ReadSentinel(321258389)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__aFeatures = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aFeatures) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aFeatures = *maybe__aFeatures;
// Sentinel = 'aFeatures'
if ((!(((&(reader__)))->ReadSentinel(290849697)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aModifiers = IPC::ReadParam<Modifiers>((&(reader__)));
if (!maybe__aModifiers) {
FatalError("Error deserializing 'Modifiers'");
return MsgValueError;
}
auto& aModifiers = *maybe__aModifiers;
// Sentinel = 'aModifiers'
if ((!(((&(reader__)))->ReadSentinel(358286340)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Modifiers'");
return MsgValueError;
}
auto maybe__aName = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aName) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aName = *maybe__aName;
// Sentinel = 'aName'
if ((!(((&(reader__)))->ReadSentinel(92537315)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aTriggeringPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aTriggeringPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aTriggeringPrincipal = *maybe__aTriggeringPrincipal;
// Sentinel = 'aTriggeringPrincipal'
if ((!(((&(reader__)))->ReadSentinel(1413089302)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__aCsp = IPC::ReadParam<RefPtr<nsIContentSecurityPolicy>>((&(reader__)));
if (!maybe__aCsp) {
FatalError("Error deserializing 'nsIContentSecurityPolicy'");
return MsgValueError;
}
auto& aCsp = *maybe__aCsp;
// Sentinel = 'aCsp'
if ((!(((&(reader__)))->ReadSentinel(61276552)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIContentSecurityPolicy'");
return MsgValueError;
}
auto maybe__aReferrerInfo = IPC::ReadParam<RefPtr<nsIReferrerInfo>>((&(reader__)));
if (!maybe__aReferrerInfo) {
FatalError("Error deserializing 'nsIReferrerInfo'");
return MsgValueError;
}
auto& aReferrerInfo = *maybe__aReferrerInfo;
// Sentinel = 'aReferrerInfo'
if ((!(((&(reader__)))->ReadSentinel(597755179)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIReferrerInfo'");
return MsgValueError;
}
auto maybe__aOriginAttributes = IPC::ReadParam<OriginAttributes>((&(reader__)));
if (!maybe__aOriginAttributes) {
FatalError("Error deserializing 'OriginAttributes'");
return MsgValueError;
}
auto& aOriginAttributes = *maybe__aOriginAttributes;
// Sentinel = 'aOriginAttributes'
if ((!(((&(reader__)))->ReadSentinel(1021839089)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributes'");
return MsgValueError;
}
auto maybe__aUserActivation = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aUserActivation) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aUserActivation = *maybe__aUserActivation;
// Sentinel = 'aUserActivation'
if ((!(((&(reader__)))->ReadSentinel(794887699)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aTextDirectiveUserActivation = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aTextDirectiveUserActivation) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aTextDirectiveUserActivation = *maybe__aTextDirectiveUserActivation;
// Sentinel = 'aTextDirectiveUserActivation'
if ((!(((&(reader__)))->ReadSentinel(2721450839)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvCreateWindowInDifferentProcess(aThisTab, std::move(aParent), std::move(aChromeFlags), std::move(aCalledFromJS), std::move(aTopLevelCreatedByContent), aURIToLoad, std::move(aFeatures), std::move(aModifiers), std::move(aName), aTriggeringPrincipal, aCsp, aReferrerInfo, std::move(aOriginAttributes), std::move(aUserActivation), std::move(aTextDirectiveUserActivation));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyBenchmarkResult__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyBenchmarkResult", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aCodecName = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aCodecName) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aCodecName = *maybe__aCodecName;
// Sentinel = 'aCodecName'
if ((!(((&(reader__)))->ReadSentinel(340394945)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aDecodeFPS = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aDecodeFPS) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aDecodeFPS = *maybe__aDecodeFPS;
// Sentinel = 'aDecodeFPS'
if ((!(((&(reader__)))->ReadSentinel(335283087)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyBenchmarkResult(std::move(aCodecName), std::move(aDecodeFPS));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyPushObservers__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushObservers", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__scope = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__scope) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& scope = *maybe__scope;
// Sentinel = 'scope'
if ((!(((&(reader__)))->ReadSentinel(107086363)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__principal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__principal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& principal = *maybe__principal;
// Sentinel = 'principal'
if ((!(((&(reader__)))->ReadSentinel(319620035)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__messageId = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__messageId) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& messageId = *maybe__messageId;
// Sentinel = 'messageId'
if ((!(((&(reader__)))->ReadSentinel(310576019)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyPushObservers(std::move(scope), principal, std::move(messageId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyPushObserversWithData__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushObserversWithData", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__scope = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__scope) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& scope = *maybe__scope;
// Sentinel = 'scope'
if ((!(((&(reader__)))->ReadSentinel(107086363)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__principal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__principal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& principal = *maybe__principal;
// Sentinel = 'principal'
if ((!(((&(reader__)))->ReadSentinel(319620035)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__messageId = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__messageId) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& messageId = *maybe__messageId;
// Sentinel = 'messageId'
if ((!(((&(reader__)))->ReadSentinel(310576019)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__data = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__data) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& data = *maybe__data;
// Sentinel = 'data'
if ((!(((&(reader__)))->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyPushObserversWithData(std::move(scope), principal, std::move(messageId), std::move(data));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyPushSubscriptionChangeObservers__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushSubscriptionChangeObservers", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__scope = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__scope) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& scope = *maybe__scope;
// Sentinel = 'scope'
if ((!(((&(reader__)))->ReadSentinel(107086363)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__principal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__principal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& principal = *maybe__principal;
// Sentinel = 'principal'
if ((!(((&(reader__)))->ReadSentinel(319620035)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyPushSubscriptionChangeObservers(std::move(scope), principal);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_GetFilesRequest__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetFilesRequest", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aID = IPC::ReadParam<nsID>((&(reader__)));
if (!maybe__aID) {
FatalError("Error deserializing 'nsID'");
return MsgValueError;
}
auto& aID = *maybe__aID;
// Sentinel = 'aID'
if ((!(((&(reader__)))->ReadSentinel(33292527)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
return MsgValueError;
}
auto maybe__aDirectory = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aDirectory) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aDirectory = *maybe__aDirectory;
// Sentinel = 'aDirectory'
if ((!(((&(reader__)))->ReadSentinel(358941719)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aRecursiveFlag = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aRecursiveFlag) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aRecursiveFlag = *maybe__aRecursiveFlag;
// Sentinel = 'aRecursiveFlag'
if ((!(((&(reader__)))->ReadSentinel(701498772)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvGetFilesRequest(std::move(aID), std::move(aDirectory), std::move(aRecursiveFlag));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_DeleteGetFilesRequest__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_DeleteGetFilesRequest", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aID = IPC::ReadParam<nsID>((&(reader__)));
if (!maybe__aID) {
FatalError("Error deserializing 'nsID'");
return MsgValueError;
}
auto& aID = *maybe__aID;
// Sentinel = 'aID'
if ((!(((&(reader__)))->ReadSentinel(33292527)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvDeleteGetFilesRequest(std::move(aID));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_StoreAndBroadcastBlobURLRegistration__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_StoreAndBroadcastBlobURLRegistration", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__url = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__url) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& url = *maybe__url;
// Sentinel = 'url'
if ((!(((&(reader__)))->ReadSentinel(45220180)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__blob = IPC::ReadParam<IPCBlob>((&(reader__)));
if (!maybe__blob) {
FatalError("Error deserializing 'IPCBlob'");
return MsgValueError;
}
auto& blob = *maybe__blob;
// Sentinel = 'blob'
if ((!(((&(reader__)))->ReadSentinel(68157856)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCBlob'");
return MsgValueError;
}
auto maybe__principal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__principal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& principal = *maybe__principal;
// Sentinel = 'principal'
if ((!(((&(reader__)))->ReadSentinel(319620035)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__aPartitionKey = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aPartitionKey) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aPartitionKey = *maybe__aPartitionKey;
// Sentinel = 'aPartitionKey'
if ((!(((&(reader__)))->ReadSentinel(610141509)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvStoreAndBroadcastBlobURLRegistration(std::move(url), std::move(blob), principal, 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_UnstoreAndBroadcastBlobURLUnregistration__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UnstoreAndBroadcastBlobURLUnregistration", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__url = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__url) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& url = *maybe__url;
// Sentinel = 'url'
if ((!(((&(reader__)))->ReadSentinel(45220180)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__principal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__principal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& principal = *maybe__principal;
// Sentinel = 'principal'
if ((!(((&(reader__)))->ReadSentinel(319620035)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvUnstoreAndBroadcastBlobURLUnregistration(std::move(url), principal);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RecordPageLoadEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RecordPageLoadEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__event = IPC::ReadParam<PageLoadExtra>((&(reader__)));
if (!maybe__event) {
FatalError("Error deserializing 'PageLoadExtra'");
return MsgValueError;
}
auto& event = *maybe__event;
// Sentinel = 'event'
if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PageLoadExtra'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvRecordPageLoadEvent(std::move(event));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AccumulateChildHistograms__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AccumulateChildHistograms", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__accumulations = IPC::ReadParam<nsTArray<HistogramAccumulation>>((&(reader__)));
if (!maybe__accumulations) {
FatalError("Error deserializing 'HistogramAccumulation[]'");
return MsgValueError;
}
auto& accumulations = *maybe__accumulations;
// Sentinel = 'accumulations'
if ((!(((&(reader__)))->ReadSentinel(632030585)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'HistogramAccumulation[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvAccumulateChildHistograms(std::move(accumulations));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AccumulateChildKeyedHistograms__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AccumulateChildKeyedHistograms", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__accumulations = IPC::ReadParam<nsTArray<KeyedHistogramAccumulation>>((&(reader__)));
if (!maybe__accumulations) {
FatalError("Error deserializing 'KeyedHistogramAccumulation[]'");
return MsgValueError;
}
auto& accumulations = *maybe__accumulations;
// Sentinel = 'accumulations'
if ((!(((&(reader__)))->ReadSentinel(632030585)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'KeyedHistogramAccumulation[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvAccumulateChildKeyedHistograms(std::move(accumulations));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UpdateChildScalars__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateChildScalars", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__updates = IPC::ReadParam<nsTArray<ScalarAction>>((&(reader__)));
if (!maybe__updates) {
FatalError("Error deserializing 'ScalarAction[]'");
return MsgValueError;
}
auto& updates = *maybe__updates;
// Sentinel = 'updates'
if ((!(((&(reader__)))->ReadSentinel(199951095)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ScalarAction[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvUpdateChildScalars(std::move(updates));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_UpdateChildKeyedScalars__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UpdateChildKeyedScalars", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__updates = IPC::ReadParam<nsTArray<KeyedScalarAction>>((&(reader__)));
if (!maybe__updates) {
FatalError("Error deserializing 'KeyedScalarAction[]'");
return MsgValueError;
}
auto& updates = *maybe__updates;
// Sentinel = 'updates'
if ((!(((&(reader__)))->ReadSentinel(199951095)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'KeyedScalarAction[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvUpdateChildKeyedScalars(std::move(updates));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RecordChildEvents__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RecordChildEvents", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__events = IPC::ReadParam<nsTArray<ChildEventData>>((&(reader__)));
if (!maybe__events) {
FatalError("Error deserializing 'ChildEventData[]'");
return MsgValueError;
}
auto& events = *maybe__events;
// Sentinel = 'events'
if ((!(((&(reader__)))->ReadSentinel(149619350)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ChildEventData[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvRecordChildEvents(std::move(events));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RecordDiscardedData__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RecordDiscardedData", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__data = IPC::ReadParam<DiscardedData>((&(reader__)));
if (!maybe__data) {
FatalError("Error deserializing 'DiscardedData'");
return MsgValueError;
}
auto& data = *maybe__data;
// Sentinel = 'data'
if ((!(((&(reader__)))->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'DiscardedData'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvRecordDiscardedData(std::move(data));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AddMemoryReport__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddMemoryReport", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aReport = IPC::ReadParam<MemoryReport>((&(reader__)));
if (!maybe__aReport) {
FatalError("Error deserializing 'MemoryReport'");
return MsgValueError;
}
auto& aReport = *maybe__aReport;
// Sentinel = 'aReport'
if ((!(((&(reader__)))->ReadSentinel(184025822)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MemoryReport'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvAddMemoryReport(std::move(aReport));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_BHRThreadHang__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_BHRThreadHang", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aHangDetails = IPC::ReadParam<HangDetails>((&(reader__)));
if (!maybe__aHangDetails) {
FatalError("Error deserializing 'HangDetails'");
return MsgValueError;
}
auto& aHangDetails = *maybe__aHangDetails;
// Sentinel = 'aHangDetails'
if ((!(((&(reader__)))->ReadSentinel(488113318)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'HangDetails'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvBHRThreadHang(std::move(aHangDetails));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AddCertException__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddCertException", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aCert = IPC::ReadParam<RefPtr<nsIX509Cert>>((&(reader__)));
if (!maybe__aCert) {
FatalError("Error deserializing 'nsIX509Cert'");
return MsgValueError;
}
auto& aCert = *maybe__aCert;
// Sentinel = 'aCert'
if ((!(((&(reader__)))->ReadSentinel(92078576)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIX509Cert'");
return MsgValueError;
}
auto maybe__aHostName = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aHostName) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aHostName = *maybe__aHostName;
// Sentinel = 'aHostName'
if ((!(((&(reader__)))->ReadSentinel(290128769)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aPort = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aPort) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aPort = *maybe__aPort;
// Sentinel = 'aPort'
if ((!(((&(reader__)))->ReadSentinel(97452551)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto maybe__aOriginAttributes = IPC::ReadParam<OriginAttributes>((&(reader__)));
if (!maybe__aOriginAttributes) {
FatalError("Error deserializing 'OriginAttributes'");
return MsgValueError;
}
auto& aOriginAttributes = *maybe__aOriginAttributes;
// Sentinel = 'aOriginAttributes'
if ((!(((&(reader__)))->ReadSentinel(1021839089)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributes'");
return MsgValueError;
}
auto maybe__aIsTemporary = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aIsTemporary) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aIsTemporary = *maybe__aIsTemporary;
// Sentinel = 'aIsTemporary'
if ((!(((&(reader__)))->ReadSentinel(509805793)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_AddCertException(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
AddCertExceptionResolver 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 = 'success'
((&(writer__)))->WriteSentinel(200082170);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvAddCertException(aCert, std::move(aHostName), std::move(aPort), std::move(aOriginAttributes), std::move(aIsTemporary), 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_AutomaticStorageAccessPermissionCanBeGranted__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AutomaticStorageAccessPermissionCanBeGranted", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aPrincipal = *maybe__aPrincipal;
// Sentinel = 'aPrincipal'
if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_AutomaticStorageAccessPermissionCanBeGranted(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
AutomaticStorageAccessPermissionCanBeGrantedResolver 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 = 'success'
((&(writer__)))->WriteSentinel(200082170);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvAutomaticStorageAccessPermissionCanBeGranted(aPrincipal, 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_StorageAccessPermissionGrantedForOrigin__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_StorageAccessPermissionGrantedForOrigin", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aTopLevelWindowId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aTopLevelWindowId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aTopLevelWindowId = *maybe__aTopLevelWindowId;
// Sentinel = 'aTopLevelWindowId'
if ((!(((&(reader__)))->ReadSentinel(1006700210)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aParentContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aParentContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aParentContext = *maybe__aParentContext;
// Sentinel = 'aParentContext'
if ((!(((&(reader__)))->ReadSentinel(692454833)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aTrackingPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aTrackingPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aTrackingPrincipal = *maybe__aTrackingPrincipal;
// Sentinel = 'aTrackingPrincipal'
if ((!(((&(reader__)))->ReadSentinel(1135609655)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__aTrackingOrigin = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aTrackingOrigin) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aTrackingOrigin = *maybe__aTrackingOrigin;
// Sentinel = 'aTrackingOrigin'
if ((!(((&(reader__)))->ReadSentinel(792331773)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aAllowMode = IPC::ReadParam<int>((&(reader__)));
if (!maybe__aAllowMode) {
FatalError("Error deserializing 'int'");
return MsgValueError;
}
auto& aAllowMode = *maybe__aAllowMode;
// Sentinel = 'aAllowMode'
if ((!(((&(reader__)))->ReadSentinel(353108966)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int'");
return MsgValueError;
}
auto maybe__aReason = IPC::ReadParam<mozilla::Maybe<StorageAccessPermissionGrantedReason>>((&(reader__)));
if (!maybe__aReason) {
FatalError("Error deserializing 'StorageAccessPermissionGrantedReason?'");
return MsgValueError;
}
auto& aReason = *maybe__aReason;
// Sentinel = 'aReason'
if ((!(((&(reader__)))->ReadSentinel(180093642)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'StorageAccessPermissionGrantedReason?'");
return MsgValueError;
}
auto maybe__aFrameOnly = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aFrameOnly) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aFrameOnly = *maybe__aFrameOnly;
// Sentinel = 'aFrameOnly'
if ((!(((&(reader__)))->ReadSentinel(350159855)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_StorageAccessPermissionGrantedForOrigin(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
StorageAccessPermissionGrantedForOriginResolver 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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvStorageAccessPermissionGrantedForOrigin(std::move(aTopLevelWindowId), std::move(aParentContext), aTrackingPrincipal, std::move(aTrackingOrigin), std::move(aAllowMode), std::move(aReason), std::move(aFrameOnly), 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_CompleteAllowAccessFor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CompleteAllowAccessFor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aParentContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aParentContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aParentContext = *maybe__aParentContext;
// Sentinel = 'aParentContext'
if ((!(((&(reader__)))->ReadSentinel(692454833)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aTopLevelWindowId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aTopLevelWindowId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aTopLevelWindowId = *maybe__aTopLevelWindowId;
// Sentinel = 'aTopLevelWindowId'
if ((!(((&(reader__)))->ReadSentinel(1006700210)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aTrackingPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aTrackingPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aTrackingPrincipal = *maybe__aTrackingPrincipal;
// Sentinel = 'aTrackingPrincipal'
if ((!(((&(reader__)))->ReadSentinel(1135609655)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__aTrackingOrigin = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aTrackingOrigin) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aTrackingOrigin = *maybe__aTrackingOrigin;
// Sentinel = 'aTrackingOrigin'
if ((!(((&(reader__)))->ReadSentinel(792331773)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aCookieBehavior = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aCookieBehavior) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aCookieBehavior = *maybe__aCookieBehavior;
// Sentinel = 'aCookieBehavior'
if ((!(((&(reader__)))->ReadSentinel(772408812)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aReason = IPC::ReadParam<StorageAccessPermissionGrantedReason>((&(reader__)));
if (!maybe__aReason) {
FatalError("Error deserializing 'StorageAccessPermissionGrantedReason'");
return MsgValueError;
}
auto& aReason = *maybe__aReason;
// Sentinel = 'aReason'
if ((!(((&(reader__)))->ReadSentinel(180093642)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'StorageAccessPermissionGrantedReason'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_CompleteAllowAccessFor(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
CompleteAllowAccessForResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<StorageAccessPromptChoices>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'choice'
((&(writer__)))->WriteSentinel(142738028);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvCompleteAllowAccessFor(std::move(aParentContext), std::move(aTopLevelWindowId), aTrackingPrincipal, std::move(aTrackingOrigin), std::move(aCookieBehavior), std::move(aReason), 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_SetAllowStorageAccessRequestFlag__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetAllowStorageAccessRequestFlag", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEmbeddingPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aEmbeddingPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aEmbeddingPrincipal = *maybe__aEmbeddingPrincipal;
// Sentinel = 'aEmbeddingPrincipal'
if ((!(((&(reader__)))->ReadSentinel(1233389443)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__aEmbeddedOrigin = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__aEmbeddedOrigin) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& aEmbeddedOrigin = *maybe__aEmbeddedOrigin;
// Sentinel = 'aEmbeddedOrigin'
if ((!(((&(reader__)))->ReadSentinel(762906068)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_SetAllowStorageAccessRequestFlag(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
SetAllowStorageAccessRequestFlagResolver 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 = 'success'
((&(writer__)))->WriteSentinel(200082170);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSetAllowStorageAccessRequestFlag(aEmbeddingPrincipal, aEmbeddedOrigin, 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_TestAllowStorageAccessRequestFlag__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_TestAllowStorageAccessRequestFlag", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEmbeddedPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aEmbeddedPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aEmbeddedPrincipal = *maybe__aEmbeddedPrincipal;
// Sentinel = 'aEmbeddedPrincipal'
if ((!(((&(reader__)))->ReadSentinel(1098123022)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__aEmbeddingOrigin = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__aEmbeddingOrigin) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& aEmbeddingOrigin = *maybe__aEmbeddingOrigin;
// Sentinel = 'aEmbeddingOrigin'
if ((!(((&(reader__)))->ReadSentinel(875169353)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_TestAllowStorageAccessRequestFlag(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
TestAllowStorageAccessRequestFlagResolver 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 = 'success'
((&(writer__)))->WriteSentinel(200082170);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvTestAllowStorageAccessRequestFlag(aEmbeddedPrincipal, aEmbeddingOrigin, 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_StoreUserInteractionAsPermission__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_StoreUserInteractionAsPermission", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aPrincipal = *maybe__aPrincipal;
// Sentinel = 'aPrincipal'
if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvStoreUserInteractionAsPermission(aPrincipal);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_TestCookiePermissionDecided__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_TestCookiePermissionDecided", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aPrincipal = *maybe__aPrincipal;
// Sentinel = 'aPrincipal'
if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_TestCookiePermissionDecided(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
TestCookiePermissionDecidedResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<bool>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'allowed'
((&(writer__)))->WriteSentinel(195101417);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvTestCookiePermissionDecided(std::move(aContext), aPrincipal, 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_TestStorageAccessPermission__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_TestStorageAccessPermission", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aEmbeddingPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aEmbeddingPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aEmbeddingPrincipal = *maybe__aEmbeddingPrincipal;
// Sentinel = 'aEmbeddingPrincipal'
if ((!(((&(reader__)))->ReadSentinel(1233389443)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__aEmbeddedOrigin = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aEmbeddedOrigin) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aEmbeddedOrigin = *maybe__aEmbeddedOrigin;
// Sentinel = 'aEmbeddedOrigin'
if ((!(((&(reader__)))->ReadSentinel(762906068)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_TestStorageAccessPermission(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
TestStorageAccessPermissionResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<bool>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'allowed'
((&(writer__)))->WriteSentinel(195101417);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvTestStorageAccessPermission(aEmbeddingPrincipal, std::move(aEmbeddedOrigin), 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_NotifyMediaPlaybackChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaPlaybackChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aState = IPC::ReadParam<MediaPlaybackState>((&(reader__)));
if (!maybe__aState) {
FatalError("Error deserializing 'MediaPlaybackState'");
return MsgValueError;
}
auto& aState = *maybe__aState;
// Sentinel = 'aState'
if ((!(((&(reader__)))->ReadSentinel(137036387)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MediaPlaybackState'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyMediaPlaybackChanged(std::move(aContext), 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_NotifyMediaAudibleChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaAudibleChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aState = IPC::ReadParam<MediaAudibleState>((&(reader__)));
if (!maybe__aState) {
FatalError("Error deserializing 'MediaAudibleState'");
return MsgValueError;
}
auto& aState = *maybe__aState;
// Sentinel = 'aState'
if ((!(((&(reader__)))->ReadSentinel(137036387)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MediaAudibleState'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyMediaAudibleChanged(std::move(aContext), 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_NotifyPictureInPictureModeChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyPictureInPictureModeChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aEnabled = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aEnabled) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aEnabled = *maybe__aEnabled;
// Sentinel = 'aEnabled'
if ((!(((&(reader__)))->ReadSentinel(224789261)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyPictureInPictureModeChanged(std::move(aContext), std::move(aEnabled));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyMediaSessionUpdated__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaSessionUpdated", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aIsCreated = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aIsCreated) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aIsCreated = *maybe__aIsCreated;
// Sentinel = 'aIsCreated'
if ((!(((&(reader__)))->ReadSentinel(344261590)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyMediaSessionUpdated(std::move(aContext), std::move(aIsCreated));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyUpdateMediaMetadata__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyUpdateMediaMetadata", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aMetadata = IPC::ReadParam<mozilla::Maybe<MediaMetadataBase>>((&(reader__)));
if (!maybe__aMetadata) {
FatalError("Error deserializing 'MediaMetadataBase?'");
return MsgValueError;
}
auto& aMetadata = *maybe__aMetadata;
// Sentinel = 'aMetadata'
if ((!(((&(reader__)))->ReadSentinel(288752515)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MediaMetadataBase?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyUpdateMediaMetadata(std::move(aContext), std::move(aMetadata));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyMediaSessionPlaybackStateChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaSessionPlaybackStateChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aMetadata = IPC::ReadParam<MediaSessionPlaybackState>((&(reader__)));
if (!maybe__aMetadata) {
FatalError("Error deserializing 'MediaSessionPlaybackState'");
return MsgValueError;
}
auto& aMetadata = *maybe__aMetadata;
// Sentinel = 'aMetadata'
if ((!(((&(reader__)))->ReadSentinel(288752515)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MediaSessionPlaybackState'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyMediaSessionPlaybackStateChanged(std::move(aContext), std::move(aMetadata));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyMediaSessionSupportedActionChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaSessionSupportedActionChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aAction = IPC::ReadParam<MediaSessionAction>((&(reader__)));
if (!maybe__aAction) {
FatalError("Error deserializing 'MediaSessionAction'");
return MsgValueError;
}
auto& aAction = *maybe__aAction;
// Sentinel = 'aAction'
if ((!(((&(reader__)))->ReadSentinel(175768256)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MediaSessionAction'");
return MsgValueError;
}
auto maybe__aEnabled = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aEnabled) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aEnabled = *maybe__aEnabled;
// Sentinel = 'aEnabled'
if ((!(((&(reader__)))->ReadSentinel(224789261)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyMediaSessionSupportedActionChanged(std::move(aContext), std::move(aAction), std::move(aEnabled));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyMediaFullScreenState__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaFullScreenState", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aIsInFullScreen = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aIsInFullScreen) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aIsInFullScreen = *maybe__aIsInFullScreen;
// Sentinel = 'aIsInFullScreen'
if ((!(((&(reader__)))->ReadSentinel(754320840)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyMediaFullScreenState(std::move(aContext), std::move(aIsInFullScreen));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyPositionStateChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyPositionStateChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aState = IPC::ReadParam<mozilla::Maybe<PositionState>>((&(reader__)));
if (!maybe__aState) {
FatalError("Error deserializing 'PositionState?'");
return MsgValueError;
}
auto& aState = *maybe__aState;
// Sentinel = 'aState'
if ((!(((&(reader__)))->ReadSentinel(137036387)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PositionState?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyPositionStateChanged(std::move(aContext), 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_NotifyGuessedPositionStateChanged__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyGuessedPositionStateChanged", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aMediaId = IPC::ReadParam<nsID>((&(reader__)));
if (!maybe__aMediaId) {
FatalError("Error deserializing 'nsID'");
return MsgValueError;
}
auto& aMediaId = *maybe__aMediaId;
// Sentinel = 'aMediaId'
if ((!(((&(reader__)))->ReadSentinel(221905647)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
return MsgValueError;
}
auto maybe__aState = IPC::ReadParam<mozilla::Maybe<PositionState>>((&(reader__)));
if (!maybe__aState) {
FatalError("Error deserializing 'PositionState?'");
return MsgValueError;
}
auto& aState = *maybe__aState;
// Sentinel = 'aState'
if ((!(((&(reader__)))->ReadSentinel(137036387)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PositionState?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyGuessedPositionStateChanged(std::move(aContext), std::move(aMediaId), 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_AddOrRemovePageAwakeRequest__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AddOrRemovePageAwakeRequest", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aShouldAddCount = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aShouldAddCount) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aShouldAddCount = *maybe__aShouldAddCount;
// Sentinel = 'aShouldAddCount'
if ((!(((&(reader__)))->ReadSentinel(777848291)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvAddOrRemovePageAwakeRequest(std::move(aContext), std::move(aShouldAddCount));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ReportServiceWorkerShutdownProgress__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReportServiceWorkerShutdownProgress", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aShutdownStateId = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aShutdownStateId) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aShutdownStateId = *maybe__aShutdownStateId;
// Sentinel = 'aShutdownStateId'
if ((!(((&(reader__)))->ReadSentinel(925238892)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aProgress = IPC::ReadParam<Progress>((&(reader__)));
if (!maybe__aProgress) {
FatalError("Error deserializing 'Progress'");
return MsgValueError;
}
auto& aProgress = *maybe__aProgress;
// Sentinel = 'aProgress'
if ((!(((&(reader__)))->ReadSentinel(301794231)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Progress'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvReportServiceWorkerShutdownProgress(std::move(aShutdownStateId), std::move(aProgress));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AbortOtherOrientationPendingPromises__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AbortOtherOrientationPendingPromises", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvAbortOtherOrientationPendingPromises(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_HistoryReload__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_HistoryReload", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aReloadFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aReloadFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aReloadFlags = *maybe__aReloadFlags;
// Sentinel = 'aReloadFlags'
if ((!(((&(reader__)))->ReadSentinel(499451046)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvHistoryReload(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_NotifyOnHistoryReload__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyOnHistoryReload", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aForceReload = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aForceReload) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aForceReload = *maybe__aForceReload;
// Sentinel = 'aForceReload'
if ((!(((&(reader__)))->ReadSentinel(500499624)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_NotifyOnHistoryReload(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
NotifyOnHistoryReloadResolver resolver = [resolver__ = std::move(resolver__)](std::tuple<const bool&, const mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>&, const mozilla::Maybe<bool>&> aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), std::get<0>(aParam));
// Sentinel = 'canReload'
((&(writer__)))->WriteSentinel(295043978);
IPC::WriteParam((&(writer__)), std::get<1>(aParam));
// Sentinel = 'loadState'
((&(writer__)))->WriteSentinel(304808866);
IPC::WriteParam((&(writer__)), std::get<2>(aParam));
// Sentinel = 'reloadActiveEntry'
((&(writer__)))->WriteSentinel(1029506790);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyOnHistoryReload(std::move(aContext), std::move(aForceReload), 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_HistoryCommit__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_HistoryCommit", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aLoadID = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aLoadID) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aLoadID = *maybe__aLoadID;
// Sentinel = 'aLoadID'
if ((!(((&(reader__)))->ReadSentinel(170328687)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aChangeID = IPC::ReadParam<nsID>((&(reader__)));
if (!maybe__aChangeID) {
FatalError("Error deserializing 'nsID'");
return MsgValueError;
}
auto& aChangeID = *maybe__aChangeID;
// Sentinel = 'aChangeID'
if ((!(((&(reader__)))->ReadSentinel(275710773)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
return MsgValueError;
}
auto maybe__aLoadType = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aLoadType) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aLoadType = *maybe__aLoadType;
// Sentinel = 'aLoadType'
if ((!(((&(reader__)))->ReadSentinel(286589828)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aPersist = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aPersist) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aPersist = *maybe__aPersist;
// Sentinel = 'aPersist'
if ((!(((&(reader__)))->ReadSentinel(238617420)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aCloneEntryChildren = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aCloneEntryChildren) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aCloneEntryChildren = *maybe__aCloneEntryChildren;
// Sentinel = 'aCloneEntryChildren'
if ((!(((&(reader__)))->ReadSentinel(1242171278)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aChannelExpired = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aChannelExpired) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aChannelExpired = *maybe__aChannelExpired;
// Sentinel = 'aChannelExpired'
if ((!(((&(reader__)))->ReadSentinel(775554540)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aCacheKey = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aCacheKey) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aCacheKey = *maybe__aCacheKey;
// Sentinel = 'aCacheKey'
if ((!(((&(reader__)))->ReadSentinel(272827231)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvHistoryCommit(std::move(aContext), std::move(aLoadID), std::move(aChangeID), std::move(aLoadType), std::move(aPersist), std::move(aCloneEntryChildren), std::move(aChannelExpired), std::move(aCacheKey));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_HistoryGo__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_HistoryGo", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aOffset = IPC::ReadParam<int32_t>((&(reader__)));
if (!maybe__aOffset) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto& aOffset = *maybe__aOffset;
// Sentinel = 'aOffset'
if ((!(((&(reader__)))->ReadSentinel(179634889)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
auto maybe__aHistoryEpoch = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aHistoryEpoch) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aHistoryEpoch = *maybe__aHistoryEpoch;
// Sentinel = 'aHistoryEpoch'
if ((!(((&(reader__)))->ReadSentinel(611255619)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aRequireUserInteraction = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aRequireUserInteraction) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aRequireUserInteraction = *maybe__aRequireUserInteraction;
// Sentinel = 'aRequireUserInteraction'
if ((!(((&(reader__)))->ReadSentinel(1862076766)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aUserActivation = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aUserActivation) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aUserActivation = *maybe__aUserActivation;
// Sentinel = 'aUserActivation'
if ((!(((&(reader__)))->ReadSentinel(794887699)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_HistoryGo(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
HistoryGoResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<int32_t>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'requestedIndex'
((&(writer__)))->WriteSentinel(738788811);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvHistoryGo(std::move(aContext), std::move(aOffset), std::move(aHistoryEpoch), std::move(aRequireUserInteraction), std::move(aUserActivation), 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_BlobURLDataRequest__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_BlobURLDataRequest", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aBlobURL = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aBlobURL) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aBlobURL = *maybe__aBlobURL;
// Sentinel = 'aBlobURL'
if ((!(((&(reader__)))->ReadSentinel(218628820)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aTriggeringPrincipal = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIPrincipal>>>((&(reader__)));
if (!maybe__aTriggeringPrincipal) {
FatalError("Error deserializing 'NotNull<nsIPrincipal>'");
return MsgValueError;
}
auto& aTriggeringPrincipal = *maybe__aTriggeringPrincipal;
// Sentinel = 'aTriggeringPrincipal'
if ((!(((&(reader__)))->ReadSentinel(1413089302)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIPrincipal>'");
return MsgValueError;
}
auto maybe__aLoadingPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aLoadingPrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aLoadingPrincipal = *maybe__aLoadingPrincipal;
// Sentinel = 'aLoadingPrincipal'
if ((!(((&(reader__)))->ReadSentinel(1001719490)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__aOriginAttributes = IPC::ReadParam<OriginAttributes>((&(reader__)));
if (!maybe__aOriginAttributes) {
FatalError("Error deserializing 'OriginAttributes'");
return MsgValueError;
}
auto& aOriginAttributes = *maybe__aOriginAttributes;
// Sentinel = 'aOriginAttributes'
if ((!(((&(reader__)))->ReadSentinel(1021839089)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributes'");
return MsgValueError;
}
auto maybe__aInnerWindowId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aInnerWindowId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aInnerWindowId = *maybe__aInnerWindowId;
// Sentinel = 'aInnerWindowId'
if ((!(((&(reader__)))->ReadSentinel(689767811)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aPartitionKey = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aPartitionKey) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aPartitionKey = *maybe__aPartitionKey;
// Sentinel = 'aPartitionKey'
if ((!(((&(reader__)))->ReadSentinel(610141509)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_BlobURLDataRequest(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
BlobURLDataRequestResolver resolver = [resolver__ = std::move(resolver__)](const BlobURLDataRequestResult& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'aResult'
((&(writer__)))->WriteSentinel(185205473);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvBlobURLDataRequest(std::move(aBlobURL), aTriggeringPrincipal, aLoadingPrincipal, std::move(aOriginAttributes), std::move(aInnerWindowId), std::move(aPartitionKey), 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_SetActiveSessionHistoryEntry__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetActiveSessionHistoryEntry", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__context = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__context) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& context = *maybe__context;
// Sentinel = 'context'
if ((!(((&(reader__)))->ReadSentinel(199164678)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__previousScrollPosition = IPC::ReadParam<mozilla::Maybe<nsPoint>>((&(reader__)));
if (!maybe__previousScrollPosition) {
FatalError("Error deserializing 'nsPoint?'");
return MsgValueError;
}
auto& previousScrollPosition = *maybe__previousScrollPosition;
// Sentinel = 'previousScrollPosition'
if ((!(((&(reader__)))->ReadSentinel(1792346434)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsPoint?'");
return MsgValueError;
}
auto maybe__info = IPC::ReadParam<SessionHistoryInfo>((&(reader__)));
if (!maybe__info) {
FatalError("Error deserializing 'SessionHistoryInfo'");
return MsgValueError;
}
auto& info = *maybe__info;
// Sentinel = 'info'
if ((!(((&(reader__)))->ReadSentinel(70058413)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SessionHistoryInfo'");
return MsgValueError;
}
auto maybe__loadType = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__loadType) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& loadType = *maybe__loadType;
// Sentinel = 'loadType'
if ((!(((&(reader__)))->ReadSentinel(246088515)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__updatedCacheKey = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__updatedCacheKey) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& updatedCacheKey = *maybe__updatedCacheKey;
// Sentinel = 'updatedCacheKey'
if ((!(((&(reader__)))->ReadSentinel(804062693)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__changeID = IPC::ReadParam<nsID>((&(reader__)));
if (!maybe__changeID) {
FatalError("Error deserializing 'nsID'");
return MsgValueError;
}
auto& changeID = *maybe__changeID;
// Sentinel = 'changeID'
if ((!(((&(reader__)))->ReadSentinel(235209460)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSetActiveSessionHistoryEntry(std::move(context), std::move(previousScrollPosition), std::move(info), std::move(loadType), std::move(updatedCacheKey), std::move(changeID));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ReplaceActiveSessionHistoryEntry__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReplaceActiveSessionHistoryEntry", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__context = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__context) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& context = *maybe__context;
// Sentinel = 'context'
if ((!(((&(reader__)))->ReadSentinel(199164678)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__info = IPC::ReadParam<SessionHistoryInfo>((&(reader__)));
if (!maybe__info) {
FatalError("Error deserializing 'SessionHistoryInfo'");
return MsgValueError;
}
auto& info = *maybe__info;
// Sentinel = 'info'
if ((!(((&(reader__)))->ReadSentinel(70058413)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SessionHistoryInfo'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvReplaceActiveSessionHistoryEntry(std::move(context), std::move(info));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_RemoveDynEntriesFromActiveSessionHistoryEntry__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RemoveDynEntriesFromActiveSessionHistoryEntry", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvRemoveDynEntriesFromActiveSessionHistoryEntry(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_RemoveFromSessionHistory__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RemoveFromSessionHistory", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__changeID = IPC::ReadParam<nsID>((&(reader__)));
if (!maybe__changeID) {
FatalError("Error deserializing 'nsID'");
return MsgValueError;
}
auto& changeID = *maybe__changeID;
// Sentinel = 'changeID'
if ((!(((&(reader__)))->ReadSentinel(235209460)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvRemoveFromSessionHistory(std::move(aContext), std::move(changeID));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CleanupPendingLoadState__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CleanupPendingLoadState", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aLoadIdentifier = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aLoadIdentifier) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aLoadIdentifier = *maybe__aLoadIdentifier;
// Sentinel = 'aLoadIdentifier'
if ((!(((&(reader__)))->ReadSentinel(767362533)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvCleanupPendingLoadState(std::move(aLoadIdentifier));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_ScriptError__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ScriptError", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__message = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__message) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& message = *maybe__message;
// Sentinel = 'message'
if ((!(((&(reader__)))->ReadSentinel(197198566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__sourceName = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__sourceName) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& sourceName = *maybe__sourceName;
// Sentinel = 'sourceName'
if ((!(((&(reader__)))->ReadSentinel(387580947)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__lineNumber = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__lineNumber) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& lineNumber = *maybe__lineNumber;
// Sentinel = 'lineNumber'
if ((!(((&(reader__)))->ReadSentinel(374932498)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__colNumber = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__colNumber) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& colNumber = *maybe__colNumber;
// Sentinel = 'colNumber'
if ((!(((&(reader__)))->ReadSentinel(304284584)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__flags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__flags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& flags = *maybe__flags;
// Sentinel = 'flags'
if ((!(((&(reader__)))->ReadSentinel(102171150)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__category = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__category) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& category = *maybe__category;
// Sentinel = 'category'
if ((!(((&(reader__)))->ReadSentinel(247333727)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__isFromPrivateWindow = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__isFromPrivateWindow) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& isFromPrivateWindow = *maybe__isFromPrivateWindow;
// Sentinel = 'isFromPrivateWindow'
if ((!(((&(reader__)))->ReadSentinel(1288964036)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__innerWindowId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__innerWindowId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& innerWindowId = *maybe__innerWindowId;
// Sentinel = 'innerWindowId'
if ((!(((&(reader__)))->ReadSentinel(627967298)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__isFromChromeContext = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__isFromChromeContext) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& isFromChromeContext = *maybe__isFromChromeContext;
// Sentinel = 'isFromChromeContext'
if ((!(((&(reader__)))->ReadSentinel(1269368756)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ReportFrameTimingData", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__loadInfo = IPC::ReadParam<LoadInfoArgs>((&(reader__)));
if (!maybe__loadInfo) {
FatalError("Error deserializing 'LoadInfoArgs'");
return MsgValueError;
}
auto& loadInfo = *maybe__loadInfo;
// Sentinel = 'loadInfo'
if ((!(((&(reader__)))->ReadSentinel(240386861)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LoadInfoArgs'");
return MsgValueError;
}
auto maybe__entryName = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__entryName) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& entryName = *maybe__entryName;
// Sentinel = 'entryName'
if ((!(((&(reader__)))->ReadSentinel(315950004)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__initiatorType = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__initiatorType) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& initiatorType = *maybe__initiatorType;
// Sentinel = 'initiatorType'
if ((!(((&(reader__)))->ReadSentinel(642647414)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aData = IPC::ReadParam<UniquePtr<PerformanceTimingData>>((&(reader__)));
if (!maybe__aData) {
FatalError("Error deserializing 'UniquePtr<PerformanceTimingData>'");
return MsgValueError;
}
auto& aData = *maybe__aData;
// Sentinel = 'aData'
if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'UniquePtr<PerformanceTimingData>'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CommitBrowsingContextTransaction", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aTransaction = IPC::ReadParam<BrowsingContextTransaction>((&(reader__)));
if (!maybe__aTransaction) {
FatalError("Error deserializing 'BrowsingContextTransaction'");
return MsgValueError;
}
auto& aTransaction = *maybe__aTransaction;
// Sentinel = 'aTransaction'
if ((!(((&(reader__)))->ReadSentinel(523371752)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'BrowsingContextTransaction'");
return MsgValueError;
}
auto maybe__aEpoch = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aEpoch) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aEpoch = *maybe__aEpoch;
// Sentinel = 'aEpoch'
if ((!(((&(reader__)))->ReadSentinel(132121169)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AsyncMessage", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aMessage = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aMessage) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aMessage = *maybe__aMessage;
// Sentinel = 'aMessage'
if ((!(((&(reader__)))->ReadSentinel(233440039)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aData = IPC::ReadParam<ClonedMessageData>((&(reader__)));
if (!maybe__aData) {
FatalError("Error deserializing 'ClonedMessageData'");
return MsgValueError;
}
auto& aData = *maybe__aData;
// Sentinel = 'aData'
if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvAsyncMessage(std::move(aMessage), std::move(aData));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_NotifyPushSubscriptionModifiedObservers__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushSubscriptionModifiedObservers", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__scope = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__scope) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& scope = *maybe__scope;
// Sentinel = 'scope'
if ((!(((&(reader__)))->ReadSentinel(107086363)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__principal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__principal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& principal = *maybe__principal;
// Sentinel = 'principal'
if ((!(((&(reader__)))->ReadSentinel(319620035)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvNotifyPushSubscriptionModifiedObservers(std::move(scope), principal);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_PushError__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PushError", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__scope = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__scope) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& scope = *maybe__scope;
// Sentinel = 'scope'
if ((!(((&(reader__)))->ReadSentinel(107086363)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__principal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__principal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& principal = *maybe__principal;
// Sentinel = 'principal'
if ((!(((&(reader__)))->ReadSentinel(319620035)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto maybe__message = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__message) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& message = *maybe__message;
// Sentinel = 'message'
if ((!(((&(reader__)))->ReadSentinel(197198566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__flags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__flags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& flags = *maybe__flags;
// Sentinel = 'flags'
if ((!(((&(reader__)))->ReadSentinel(102171150)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPushError(std::move(scope), principal, std::move(message), std::move(flags));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CreateBrowsingContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CreateBrowsingContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aGroupId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aGroupId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aGroupId = *maybe__aGroupId;
// Sentinel = 'aGroupId'
if ((!(((&(reader__)))->ReadSentinel(233964316)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aInit = IPC::ReadParam<BrowsingContextInitializer>((&(reader__)));
if (!maybe__aInit) {
FatalError("Error deserializing 'BrowsingContextInitializer'");
return MsgValueError;
}
auto& aInit = *maybe__aInit;
// Sentinel = 'aInit'
if ((!(((&(reader__)))->ReadSentinel(94241270)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'BrowsingContextInitializer'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_DiscardBrowsingContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<uint64_t> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__unused = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__unused) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& unused = *maybe__unused;
// Sentinel = 'unused'
if ((!(((&(reader__)))->ReadSentinel(155517589)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(unused));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Msg_DiscardBrowsingContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_DiscardBrowsingContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aDoDiscard = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aDoDiscard) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aDoDiscard = *maybe__aDoDiscard;
// Sentinel = 'aDoDiscard'
if ((!(((&(reader__)))->ReadSentinel(339215311)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_DiscardBrowsingContext(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
DiscardBrowsingContextResolver resolver = [resolver__ = std::move(resolver__)](const uint64_t& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'unused'
((&(writer__)))->WriteSentinel(155517589);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AdjustWindowFocus", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aIsVisible = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aIsVisible) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aIsVisible = *maybe__aIsVisible;
// Sentinel = 'aIsVisible'
if ((!(((&(reader__)))->ReadSentinel(353567724)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__aShouldClearAncestorFocus = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aShouldClearAncestorFocus) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aShouldClearAncestorFocus = *maybe__aShouldClearAncestorFocus;
// Sentinel = 'aShouldClearAncestorFocus'
if ((!(((&(reader__)))->ReadSentinel(2138442231)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aAncestorBrowsingContextToFocus = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aAncestorBrowsingContextToFocus) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aAncestorBrowsingContextToFocus = *maybe__aAncestorBrowsingContextToFocus;
// Sentinel = 'aAncestorBrowsingContextToFocus'
if ((!(((&(reader__)))->ReadSentinel(3344239764)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_WindowClose", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aTrustedCaller = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aTrustedCaller) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aTrustedCaller = *maybe__aTrustedCaller;
// Sentinel = 'aTrustedCaller'
if ((!(((&(reader__)))->ReadSentinel(706479520)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_WindowFocus", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aCallerType = IPC::ReadParam<CallerType>((&(reader__)));
if (!maybe__aCallerType) {
FatalError("Error deserializing 'CallerType'");
return MsgValueError;
}
auto& aCallerType = *maybe__aCallerType;
// Sentinel = 'aCallerType'
if ((!(((&(reader__)))->ReadSentinel(422118487)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CallerType'");
return MsgValueError;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_WindowBlur", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aCallerType = IPC::ReadParam<CallerType>((&(reader__)));
if (!maybe__aCallerType) {
FatalError("Error deserializing 'CallerType'");
return MsgValueError;
}
auto& aCallerType = *maybe__aCallerType;
// Sentinel = 'aCallerType'
if ((!(((&(reader__)))->ReadSentinel(422118487)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CallerType'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RaiseWindow", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aCallerType = IPC::ReadParam<CallerType>((&(reader__)));
if (!maybe__aCallerType) {
FatalError("Error deserializing 'CallerType'");
return MsgValueError;
}
auto& aCallerType = *maybe__aCallerType;
// Sentinel = 'aCallerType'
if ((!(((&(reader__)))->ReadSentinel(422118487)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CallerType'");
return MsgValueError;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClearFocus", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetFocusedBrowsingContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetActiveBrowsingContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_UnsetActiveBrowsingContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetFocusedElement", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aNeedsFocus = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aNeedsFocus) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aNeedsFocus = *maybe__aNeedsFocus;
// Sentinel = 'aNeedsFocus'
if ((!(((&(reader__)))->ReadSentinel(419759185)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FinalizeFocusOuter", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aCanFocus = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aCanFocus) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aCanFocus = *maybe__aCanFocus;
// Sentinel = 'aCanFocus'
if ((!(((&(reader__)))->ReadSentinel(275055476)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aCallerType = IPC::ReadParam<CallerType>((&(reader__)));
if (!maybe__aCallerType) {
FatalError("Error deserializing 'CallerType'");
return MsgValueError;
}
auto& aCallerType = *maybe__aCallerType;
// Sentinel = 'aCallerType'
if ((!(((&(reader__)))->ReadSentinel(422118487)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CallerType'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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_InsertNewFocusActionId__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InsertNewFocusActionId", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvInsertNewFocusActionId(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_BlurToParent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_BlurToParent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aFocusedBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aFocusedBrowsingContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aFocusedBrowsingContext = *maybe__aFocusedBrowsingContext;
// Sentinel = 'aFocusedBrowsingContext'
if ((!(((&(reader__)))->ReadSentinel(1842153819)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aBrowsingContextToClear = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aBrowsingContextToClear) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aBrowsingContextToClear = *maybe__aBrowsingContextToClear;
// Sentinel = 'aBrowsingContextToClear'
if ((!(((&(reader__)))->ReadSentinel(1859127612)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aAncestorBrowsingContextToFocus = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aAncestorBrowsingContextToFocus) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aAncestorBrowsingContextToFocus = *maybe__aAncestorBrowsingContextToFocus;
// Sentinel = 'aAncestorBrowsingContextToFocus'
if ((!(((&(reader__)))->ReadSentinel(3344239764)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aIsLeavingDocument = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aIsLeavingDocument) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aIsLeavingDocument = *maybe__aIsLeavingDocument;
// Sentinel = 'aIsLeavingDocument'
if ((!(((&(reader__)))->ReadSentinel(1103169315)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aAdjustWidget = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aAdjustWidget) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aAdjustWidget = *maybe__aAdjustWidget;
// Sentinel = 'aAdjustWidget'
if ((!(((&(reader__)))->ReadSentinel(594609457)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aBrowsingContextToClearHandled = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aBrowsingContextToClearHandled) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aBrowsingContextToClearHandled = *maybe__aBrowsingContextToClearHandled;
// Sentinel = 'aBrowsingContextToClearHandled'
if ((!(((&(reader__)))->ReadSentinel(3118074860)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aAncestorBrowsingContextToFocusHandled = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aAncestorBrowsingContextToFocusHandled) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aAncestorBrowsingContextToFocusHandled = *maybe__aAncestorBrowsingContextToFocusHandled;
// Sentinel = 'aAncestorBrowsingContextToFocusHandled'
if ((!(((&(reader__)))->ReadSentinel(701894468)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aActionId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aActionId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aActionId = *maybe__aActionId;
// Sentinel = 'aActionId'
if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvBlurToParent(std::move(aFocusedBrowsingContext), std::move(aBrowsingContextToClear), std::move(aAncestorBrowsingContextToFocus), std::move(aIsLeavingDocument), std::move(aAdjustWidget), std::move(aBrowsingContextToClearHandled), std::move(aAncestorBrowsingContextToFocusHandled), 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_MaybeExitFullscreen__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_MaybeExitFullscreen", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_WindowPostMessage", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aMessage = IPC::ReadParam<ClonedOrErrorMessageData>((&(reader__)));
if (!maybe__aMessage) {
FatalError("Error deserializing 'ClonedOrErrorMessageData'");
return MsgValueError;
}
auto& aMessage = *maybe__aMessage;
// Sentinel = 'aMessage'
if ((!(((&(reader__)))->ReadSentinel(233440039)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClonedOrErrorMessageData'");
return MsgValueError;
}
auto maybe__aData = IPC::ReadParam<PostMessageData>((&(reader__)));
if (!maybe__aData) {
FatalError("Error deserializing 'PostMessageData'");
return MsgValueError;
}
auto& aData = *maybe__aData;
// Sentinel = 'aData'
if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PostMessageData'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvWindowPostMessage(std::move(aContext), std::move(aMessage), std::move(aData));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_CommitWindowContextTransaction__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_CommitWindowContextTransaction", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
if (!maybe__aContext) {
FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto& aContext = *maybe__aContext;
// Sentinel = 'aContext'
if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto maybe__aTransaction = IPC::ReadParam<WindowContextTransaction>((&(reader__)));
if (!maybe__aTransaction) {
FatalError("Error deserializing 'WindowContextTransaction'");
return MsgValueError;
}
auto& aTransaction = *maybe__aTransaction;
// Sentinel = 'aTransaction'
if ((!(((&(reader__)))->ReadSentinel(523371752)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WindowContextTransaction'");
return MsgValueError;
}
auto maybe__aEpoch = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__aEpoch) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& aEpoch = *maybe__aEpoch;
// Sentinel = 'aEpoch'
if ((!(((&(reader__)))->ReadSentinel(132121169)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(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::Reply_DiscardWindowContext__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_DiscardWindowContext", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<bool> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__unused = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__unused) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& unused = *maybe__unused;
// Sentinel = 'unused'
if ((!(((&(reader__)))->ReadSentinel(155517589)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(unused));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Msg_FOGData__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FOGData", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__buf = IPC::ReadParam<ByteBuf>((&(reader__)));
if (!maybe__buf) {
FatalError("Error deserializing 'ByteBuf'");
return MsgValueError;
}
auto& buf = *maybe__buf;
// Sentinel = 'buf'
if ((!(((&(reader__)))->ReadSentinel(41484606)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ByteBuf'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvFOGData(std::move(buf));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Reply_FlushFOGData__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_FlushFOGData", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<ByteBuf> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__buf = IPC::ReadParam<ByteBuf>((&(reader__)));
if (!maybe__buf) {
FatalError("Error deserializing 'ByteBuf'");
return MsgValueError;
}
auto& buf = *maybe__buf;
// Sentinel = 'buf'
if ((!(((&(reader__)))->ReadSentinel(41484606)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ByteBuf'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(buf));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PContent::Msg_SetContainerFeaturePolicy__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SetContainerFeaturePolicy", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aContainerContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aContainerContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aContainerContext = *maybe__aContainerContext;
// Sentinel = 'aContainerContext'
if ((!(((&(reader__)))->ReadSentinel(1015744234)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aContainerFeaturePolicyInfo = IPC::ReadParam<MaybeFeaturePolicyInfo>((&(reader__)));
if (!maybe__aContainerFeaturePolicyInfo) {
FatalError("Error deserializing 'MaybeFeaturePolicyInfo'");
return MsgValueError;
}
auto& aContainerFeaturePolicyInfo = *maybe__aContainerFeaturePolicyInfo;
// Sentinel = 'aContainerFeaturePolicyInfo'
if ((!(((&(reader__)))->ReadSentinel(2516585165)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeFeaturePolicyInfo'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSetContainerFeaturePolicy(std::move(aContainerContext), std::move(aContainerFeaturePolicyInfo));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_GetSystemIcon__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetSystemIcon", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aURI = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__aURI) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& aURI = *maybe__aURI;
// Sentinel = 'aURI'
if ((!(((&(reader__)))->ReadSentinel(57934162)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_GetSystemIcon(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
GetSystemIconResolver resolver = [resolver__ = std::move(resolver__)](std::tuple<const nsresult&, mozilla::Maybe<ByteBuf>&&> aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), std::get<0>(aParam));
// Sentinel = 'aResult'
((&(writer__)))->WriteSentinel(185205473);
IPC::WriteParam((&(writer__)), std::move(std::get<1>(aParam)));
// Sentinel = 'aData'
((&(writer__)))->WriteSentinel(90571228);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvGetSystemIcon(aURI, 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_GetSystemGeolocationPermissionBehavior__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetSystemGeolocationPermissionBehavior", OTHER);
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_GetSystemGeolocationPermissionBehavior(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
GetSystemGeolocationPermissionBehaviorResolver resolver = [resolver__ = std::move(resolver__)](const SystemGeolocationPermissionBehavior& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'permission'
((&(writer__)))->WriteSentinel(394921034);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvGetSystemGeolocationPermissionBehavior(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_RequestGeolocationPermissionFromUser__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_RequestGeolocationPermissionFromUser", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
if (!maybe__aBrowsingContext) {
FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto& aBrowsingContext = *maybe__aBrowsingContext;
// Sentinel = 'aBrowsingContext'
if ((!(((&(reader__)))->ReadSentinel(915015314)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PContent::Reply_RequestGeolocationPermissionFromUser(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestGeolocationPermissionFromUserResolver resolver = [resolver__ = std::move(resolver__)](const GeolocationPermissionStatus& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'aStatus'
((&(writer__)))->WriteSentinel(186712806);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvRequestGeolocationPermissionFromUser(std::move(aBrowsingContext), 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_AttributionEvent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AttributionEvent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aSourceHost = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aSourceHost) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aSourceHost = *maybe__aSourceHost;
// Sentinel = 'aSourceHost'
if ((!(((&(reader__)))->ReadSentinel(439551089)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aType = IPC::ReadParam<PrivateAttributionImpressionType>((&(reader__)));
if (!maybe__aType) {
FatalError("Error deserializing 'PrivateAttributionImpressionType'");
return MsgValueError;
}
auto& aType = *maybe__aType;
// Sentinel = 'aType'
if ((!(((&(reader__)))->ReadSentinel(99222020)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PrivateAttributionImpressionType'");
return MsgValueError;
}
auto maybe__aIndex = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aIndex) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aIndex = *maybe__aIndex;
// Sentinel = 'aIndex'
if ((!(((&(reader__)))->ReadSentinel(132055642)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aAd = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aAd) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aAd = *maybe__aAd;
// Sentinel = 'aAd'
if ((!(((&(reader__)))->ReadSentinel(34341127)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aTargetHost = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aTargetHost) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aTargetHost = *maybe__aTargetHost;
// Sentinel = 'aTargetHost'
if ((!(((&(reader__)))->ReadSentinel(431031399)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvAttributionEvent(std::move(aSourceHost), std::move(aType), std::move(aIndex), std::move(aAd), std::move(aTargetHost));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PContent::Msg_AttributionConversion__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_AttributionConversion", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aTargetHost = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aTargetHost) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aTargetHost = *maybe__aTargetHost;
// Sentinel = 'aTargetHost'
if ((!(((&(reader__)))->ReadSentinel(431031399)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aTask = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aTask) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aTask = *maybe__aTask;
// Sentinel = 'aTask'
if ((!(((&(reader__)))->ReadSentinel(95289845)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aHistogramSize = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aHistogramSize) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aHistogramSize = *maybe__aHistogramSize;
// Sentinel = 'aHistogramSize'
if ((!(((&(reader__)))->ReadSentinel(703399339)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aLookbackDays = IPC::ReadParam<mozilla::Maybe<uint32_t>>((&(reader__)));
if (!maybe__aLookbackDays) {
FatalError("Error deserializing 'uint32_t?'");
return MsgValueError;
}
auto& aLookbackDays = *maybe__aLookbackDays;
// Sentinel = 'aLookbackDays'
if ((!(((&(reader__)))->ReadSentinel(589301017)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t?'");
return MsgValueError;
}
auto maybe__aImpressionType = IPC::ReadParam<mozilla::Maybe<PrivateAttributionImpressionType>>((&(reader__)));
if (!maybe__aImpressionType) {
FatalError("Error deserializing 'PrivateAttributionImpressionType?'");
return MsgValueError;
}
auto& aImpressionType = *maybe__aImpressionType;
// Sentinel = 'aImpressionType'
if ((!(((&(reader__)))->ReadSentinel(815728173)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PrivateAttributionImpressionType?'");
return MsgValueError;
}
auto maybe__aAds = IPC::ReadParam<nsTArray<nsString>>((&(reader__)));
if (!maybe__aAds) {
FatalError("Error deserializing 'nsString[]'");
return MsgValueError;
}
auto& aAds = *maybe__aAds;
// Sentinel = 'aAds'
if ((!(((&(reader__)))->ReadSentinel(59113850)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString[]'");
return MsgValueError;
}
auto maybe__aImpressionSourceHosts = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
if (!maybe__aImpressionSourceHosts) {
FatalError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto& aImpressionSourceHosts = *maybe__aImpressionSourceHosts;
// Sentinel = 'aImpressionSourceHosts'
if ((!(((&(reader__)))->ReadSentinel(1726679309)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvAttributionConversion(std::move(aTargetHost), std::move(aTask), std::move(aHistogramSize), std::move(aLookbackDays), std::move(aImpressionType), std::move(aAds), std::move(aImpressionSourceHosts));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
default:
return MsgNotKnown;
case SHMEM_CREATED_MESSAGE_TYPE:
{
if (!ShmemCreated(msg__)) {
return MsgPayloadError;
}
return MsgProcessed;
}
case SHMEM_DESTROYED_MESSAGE_TYPE:
{
if (!ShmemDestroyed(msg__)) {
return MsgPayloadError;
}
return MsgProcessed;
}
}
}
auto PContentParent::OnMessageReceived(
const Message& msg__,
UniquePtr<Message>& reply__) -> PContentParent::Result
{
int32_t route__ = msg__.routing_id();
if (MSG_ROUTING_CONTROL != route__) {
IProtocol* routed__ = Lookup(route__);
if (!routed__ || !routed__->GetLifecycleProxy()) {
return MsgRouteError;
}
RefPtr<mozilla::ipc::ActorLifecycleProxy> proxy__ =
routed__->GetLifecycleProxy();
return proxy__->Get()->OnMessageReceived(msg__, reply__);
}
switch (msg__.type()) {
case PContent::Msg_IsSecureURI__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_IsSecureURI", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aURI = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__aURI) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& aURI = *maybe__aURI;
// Sentinel = 'aURI'
if ((!(((&(reader__)))->ReadSentinel(57934162)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__aOriginAttributes = IPC::ReadParam<OriginAttributes>((&(reader__)));
if (!maybe__aOriginAttributes) {
FatalError("Error deserializing 'OriginAttributes'");
return MsgValueError;
}
auto& aOriginAttributes = *maybe__aOriginAttributes;
// Sentinel = 'aOriginAttributes'
if ((!(((&(reader__)))->ReadSentinel(1021839089)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributes'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
bool isSecureURI{};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvIsSecureURI(aURI, std::move(aOriginAttributes), (&(isSecureURI)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PContent::Reply_IsSecureURI(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), isSecureURI);
// Sentinel = 'isSecureURI'
((&(writer__)))->WriteSentinel(441189428);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PContent::Msg_PURLClassifierConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_PURLClassifierConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto maybe__principal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__principal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& principal = *maybe__principal;
// Sentinel = 'principal'
if ((!(((&(reader__)))->ReadSentinel(319620035)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
reader__.EndRead();
bool success{};
PURLClassifierParent* actor = (static_cast<ContentParent*>(this))->AllocPURLClassifierParent(principal, (&(success)));
if (!actor) {
NS_WARNING("Cannot bind null PURLClassifierParent actor");
return MsgValueError;
}
if (!actor->SetManagerAndRegister(this, (handle__).mId)) {
NS_WARNING("Failed to bind PURLClassifierParent actor");
return MsgValueError;
}
int32_t id__ = MSG_ROUTING_CONTROL;
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvPURLClassifierConstructor(std::move(actor), principal, (&(success)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PContent::Reply_PURLClassifierConstructor(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), success);
// Sentinel = 'success'
((&(writer__)))->WriteSentinel(200082170);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PContent::Msg_SyncMessage__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_SyncMessage", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aMessage = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aMessage) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aMessage = *maybe__aMessage;
// Sentinel = 'aMessage'
if ((!(((&(reader__)))->ReadSentinel(233440039)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aData = IPC::ReadParam<ClonedMessageData>((&(reader__)));
if (!maybe__aData) {
FatalError("Error deserializing 'ClonedMessageData'");
return MsgValueError;
}
auto& aData = *maybe__aData;
// Sentinel = 'aData'
if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
nsTArray<StructuredCloneData> retval{};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvSyncMessage(std::move(aMessage), std::move(aData), (&(retval)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PContent::Reply_SyncMessage(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), retval);
// Sentinel = 'retval'
((&(writer__)))->WriteSentinel(151716495);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PContent::Msg_GetClipboard__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetClipboard", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aTypes = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
if (!maybe__aTypes) {
FatalError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto& aTypes = *maybe__aTypes;
// Sentinel = 'aTypes'
if ((!(((&(reader__)))->ReadSentinel(140575351)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto maybe__aWhichClipboard = IPC::ReadParam<ClipboardType>((&(reader__)));
if (!maybe__aWhichClipboard) {
FatalError("Error deserializing 'ClipboardType'");
return MsgValueError;
}
auto& aWhichClipboard = *maybe__aWhichClipboard;
// Sentinel = 'aWhichClipboard'
if ((!(((&(reader__)))->ReadSentinel(776996325)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
return MsgValueError;
}
auto maybe__aRequestingWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
if (!maybe__aRequestingWindowContext) {
FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto& aRequestingWindowContext = *maybe__aRequestingWindowContext;
// Sentinel = 'aRequestingWindowContext'
if ((!(((&(reader__)))->ReadSentinel(2049051110)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
IPCTransferableDataOrError transferableDataOrError{};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvGetClipboard(std::move(aTypes), std::move(aWhichClipboard), std::move(aRequestingWindowContext), (&(transferableDataOrError)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PContent::Reply_GetClipboard(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), std::move(transferableDataOrError));
// Sentinel = 'transferableDataOrError'
((&(writer__)))->WriteSentinel(1880557887);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PContent::Msg_GetClipboardDataSnapshotSync__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetClipboardDataSnapshotSync", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aTypes = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
if (!maybe__aTypes) {
FatalError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto& aTypes = *maybe__aTypes;
// Sentinel = 'aTypes'
if ((!(((&(reader__)))->ReadSentinel(140575351)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto maybe__aWhichClipboard = IPC::ReadParam<ClipboardType>((&(reader__)));
if (!maybe__aWhichClipboard) {
FatalError("Error deserializing 'ClipboardType'");
return MsgValueError;
}
auto& aWhichClipboard = *maybe__aWhichClipboard;
// Sentinel = 'aWhichClipboard'
if ((!(((&(reader__)))->ReadSentinel(776996325)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
return MsgValueError;
}
auto maybe__aRequestingWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
if (!maybe__aRequestingWindowContext) {
FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto& aRequestingWindowContext = *maybe__aRequestingWindowContext;
// Sentinel = 'aRequestingWindowContext'
if ((!(((&(reader__)))->ReadSentinel(2049051110)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
ClipboardReadRequestOrError aClipboardReadRequestOrError{};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvGetClipboardDataSnapshotSync(std::move(aTypes), std::move(aWhichClipboard), std::move(aRequestingWindowContext), (&(aClipboardReadRequestOrError)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PContent::Reply_GetClipboardDataSnapshotSync(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), std::move(aClipboardReadRequestOrError));
// Sentinel = 'aClipboardReadRequestOrError'
((&(writer__)))->WriteSentinel(2662402850);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PContent::Msg_ClipboardHasType__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_ClipboardHasType", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aTypes = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
if (!maybe__aTypes) {
FatalError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto& aTypes = *maybe__aTypes;
// Sentinel = 'aTypes'
if ((!(((&(reader__)))->ReadSentinel(140575351)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
return MsgValueError;
}
auto maybe__aWhichClipboard = IPC::ReadParam<ClipboardType>((&(reader__)));
if (!maybe__aWhichClipboard) {
FatalError("Error deserializing 'ClipboardType'");
return MsgValueError;
}
auto& aWhichClipboard = *maybe__aWhichClipboard;
// Sentinel = 'aWhichClipboard'
if ((!(((&(reader__)))->ReadSentinel(776996325)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
bool hasType{};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvClipboardHasType(std::move(aTypes), std::move(aWhichClipboard), (&(hasType)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PContent::Reply_ClipboardHasType(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), hasType);
// Sentinel = 'hasType'
((&(writer__)))->WriteSentinel(191103711);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PContent::Msg_GetIconForExtension__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetIconForExtension", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aFileExt = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aFileExt) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aFileExt = *maybe__aFileExt;
// Sentinel = 'aFileExt'
if ((!(((&(reader__)))->ReadSentinel(223544083)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__aIconSize = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aIconSize) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aIconSize = *maybe__aIconSize;
// Sentinel = 'aIconSize'
if ((!(((&(reader__)))->ReadSentinel(286196614)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
nsTArray<uint8_t> bits{};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvGetIconForExtension(std::move(aFileExt), std::move(aIconSize), (&(bits)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PContent::Reply_GetIconForExtension(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), bits);
// Sentinel = 'bits'
((&(writer__)))->WriteSentinel(69337523);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PContent::Msg_BeginDriverCrashGuard__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_BeginDriverCrashGuard", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aGuardType = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aGuardType) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aGuardType = *maybe__aGuardType;
// Sentinel = 'aGuardType'
if ((!(((&(reader__)))->ReadSentinel(356647927)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
bool crashDetected{};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvBeginDriverCrashGuard(std::move(aGuardType), (&(crashDetected)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PContent::Reply_BeginDriverCrashGuard(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), crashDetected);
// Sentinel = 'crashDetected'
((&(writer__)))->WriteSentinel(610731316);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PContent::Msg_EndDriverCrashGuard__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_EndDriverCrashGuard", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aGuardType = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aGuardType) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aGuardType = *maybe__aGuardType;
// Sentinel = 'aGuardType'
if ((!(((&(reader__)))->ReadSentinel(356647927)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvEndDriverCrashGuard(std::move(aGuardType));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PContent::Reply_EndDriverCrashGuard(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PContent::Msg_GetFontListShmBlock__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetFontListShmBlock", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aGeneration = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aGeneration) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aGeneration = *maybe__aGeneration;
// Sentinel = 'aGeneration'
if ((!(((&(reader__)))->ReadSentinel(430179438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aIndex = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aIndex) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aIndex = *maybe__aIndex;
// Sentinel = 'aIndex'
if ((!(((&(reader__)))->ReadSentinel(132055642)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
SharedMemoryHandle aHandle{};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvGetFontListShmBlock(std::move(aGeneration), std::move(aIndex), (&(aHandle)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PContent::Reply_GetFontListShmBlock(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), std::move(aHandle));
// Sentinel = 'aHandle'
((&(writer__)))->WriteSentinel(174326446);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PContent::Msg_InitializeFamily__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitializeFamily", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aGeneration = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aGeneration) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aGeneration = *maybe__aGeneration;
// Sentinel = 'aGeneration'
if ((!(((&(reader__)))->ReadSentinel(430179438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aFamilyIndex = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aFamilyIndex) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aFamilyIndex = *maybe__aFamilyIndex;
// Sentinel = 'aFamilyIndex'
if ((!(((&(reader__)))->ReadSentinel(501089468)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aLoadCmaps = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aLoadCmaps) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aLoadCmaps = *maybe__aLoadCmaps;
// Sentinel = 'aLoadCmaps'
if ((!(((&(reader__)))->ReadSentinel(342885334)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvInitializeFamily(std::move(aGeneration), std::move(aFamilyIndex), std::move(aLoadCmaps));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PContent::Reply_InitializeFamily(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PContent::Msg_InitOtherFamilyNames__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_InitOtherFamilyNames", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aGeneration = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aGeneration) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aGeneration = *maybe__aGeneration;
// Sentinel = 'aGeneration'
if ((!(((&(reader__)))->ReadSentinel(430179438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aDefer = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aDefer) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aDefer = *maybe__aDefer;
// Sentinel = 'aDefer'
if ((!(((&(reader__)))->ReadSentinel(128057928)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
bool aLoaded{};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvInitOtherFamilyNames(std::move(aGeneration), std::move(aDefer), (&(aLoaded)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PContent::Reply_InitOtherFamilyNames(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), aLoaded);
// Sentinel = 'aLoaded'
((&(writer__)))->WriteSentinel(176095915);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PContent::Msg_GetHyphDict__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PContent::Msg_GetHyphDict", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aURI = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__aURI) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& aURI = *maybe__aURI;
// Sentinel = 'aURI'
if ((!(((&(reader__)))->ReadSentinel(57934162)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
SharedMemoryHandle aHandle{};
uint32_t aSize{};
mozilla::ipc::IPCResult __ok = (static_cast<ContentParent*>(this))->RecvGetHyphDict(aURI, (&(aHandle)), (&(aSize)));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PContent::Reply_GetHyphDict(id__);
IPC::MessageWriter writer__{
(*(reply__)),
this};
IPC::WriteParam((&(writer__)), std::move(aHandle));
// Sentinel = 'aHandle'
((&(writer__)))->WriteSentinel(174326446);
IPC::WriteParam((&(writer__)), aSize);
// Sentinel = 'aSize'
((&(writer__)))->WriteSentinel(97124861);
if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PContentParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
default:
return MsgNotKnown;
}
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::PContentParent*>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
MOZ_RELEASE_ASSERT(
aWriter->GetActor(),
"Cannot serialize managed actors without an actor");
int32_t id;
if (!aVar) {
id = 0; // kNullActorId
} else {
id = aVar->Id();
if (id == 1) { // kFreedActorId
aVar->FatalError("Actor has been |delete|d");
}
MOZ_RELEASE_ASSERT(
aWriter->GetActor()->GetIPCChannel() == aVar->GetIPCChannel(),
"Actor must be from the same channel as the"
" actor it's being sent over");
MOZ_RELEASE_ASSERT(
aVar->CanSend(),
"Actor must still be open when sending");
}
IPC::WriteParam(aWriter, id);
}
auto ParamTraits<::mozilla::dom::PContentParent*>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
MOZ_RELEASE_ASSERT(
aReader->GetActor(),
"Cannot deserialize managed actors without an actor");
mozilla::Maybe<mozilla::ipc::IProtocol*> actor = aReader->GetActor()
->ReadActor(aReader, true, "PContent", PContentMsgStart);
if (actor.isSome()) {
return static_cast<::mozilla::dom::PContentParent*>(actor.ref());
}
return {};
}
} // namespace IPC