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

Copy as Markdown

Other Tools

//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/PWindowGlobalParent.h"
#include "ipc/ErrorIPCUtils.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/RemoteLazyInputStream.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/BindingIPCUtils.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/ClientIPCUtils.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/FeaturePolicyUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/IdentityCredentialSerializationHelpers.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/SessionHistoryEntry.h"
#include "mozilla/dom/SessionStoreMessageUtils.h"
#include "mozilla/dom/TabMessageUtils.h"
#include "mozilla/dom/WindowGlobalParent.h"
#include "mozilla/ipc/BigBuffer.h"
#include "mozilla/ipc/IPCCore.h"
#include "mozilla/ipc/IPCStreamUtils.h"
#include "mozilla/ipc/SerializedStructuredCloneBuffer.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/net/CacheInfoIPCTypes.h"
#include "mozilla/net/ClassOfService.h"
#include "nsDOMNavigationTiming.h"
#include "nsDocShellLoadState.h"
#include "nsHttp.h"
#include "nsHttpResponseHead.h"
#include "nsIContentSecurityPolicy.h"
#include "nsIPrincipal.h"
#include "nsIPropertyBag2.h"
#include "nsIReferrerInfo.h"
#include "nsITransportSecurityInfo.h"
#include "nsIURI.h"
#include "nsIVariant.h"
#include "nsPoint.h"
#include "mozilla/dom/PBrowserParent.h"
#include "mozilla/dom/PInProcessParent.h"
#include "mozilla/dom/PBrowserBridgeParent.h"
#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"
namespace mozilla {
namespace dom {
MOZ_IMPLICIT PWindowGlobalParent::PWindowGlobalParent() :
mozilla::ipc::IRefCountedProtocol(PWindowGlobalMsgStart, mozilla::ipc::ParentSide)
{
MOZ_COUNT_CTOR(PWindowGlobalParent);
}
PWindowGlobalParent::~PWindowGlobalParent()
{
MOZ_COUNT_DTOR(PWindowGlobalParent);
}
auto PWindowGlobalParent::ActorAlloc() -> void
{
AddRef();
}
auto PWindowGlobalParent::ActorDealloc() -> void
{
Release();
}
auto PWindowGlobalParent::AllManagedActorsCount() const -> uint32_t
{
uint32_t total = 0;
return total;
}
auto PWindowGlobalParent::Send__delete__(PWindowGlobalParent* actor) -> bool
{
if (!actor || !actor->CanSend()) {
NS_WARNING("Attempt to __delete__ missing or closed actor");
return false;
}
UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg___delete__((actor)->Id());
IPC::MessageWriter writer__{
(*(msg__)),
actor};
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
actor->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg___delete__", OTHER);
bool sendok__ = (actor)->ChannelSend(std::move(msg__));
actor->ActorDisconnected(Deletion);
return sendok__;
}
auto PWindowGlobalParent::SendMakeFrameLocal(
const MaybeDiscardedBrowsingContext& aFrameContext,
const uint64_t& aSwitchId) -> bool
{
UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_MakeFrameLocal(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aFrameContext);
// Sentinel = 'aFrameContext'
((&(writer__)))->WriteSentinel(585565490);
IPC::WriteParam((&(writer__)), aSwitchId);
// Sentinel = 'aSwitchId'
((&(writer__)))->WriteSentinel(297730945);
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_MakeFrameLocal", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PWindowGlobalParent::SendMakeFrameRemote(
const MaybeDiscardedBrowsingContext& aFrameContext,
ManagedEndpoint<::mozilla::dom::PBrowserBridgeChild>&& aEndpoint,
const TabId& aTabId,
const LayersId& aLayersId,
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_MakeFrameRemote(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aFrameContext);
// Sentinel = 'aFrameContext'
((&(writer__)))->WriteSentinel(585565490);
IPC::WriteParam((&(writer__)), std::move(aEndpoint));
// Sentinel = 'aEndpoint'
((&(writer__)))->WriteSentinel(292225955);
IPC::WriteParam((&(writer__)), aTabId);
// Sentinel = 'aTabId'
((&(writer__)))->WriteSentinel(126878246);
IPC::WriteParam((&(writer__)), aLayersId);
// Sentinel = 'aLayersId'
((&(writer__)))->WriteSentinel(291439487);
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_MakeFrameRemote", OTHER);
ChannelSend(std::move(msg__), PWindowGlobal::Reply_MakeFrameRemote__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PWindowGlobalParent::SendMakeFrameRemote(
const MaybeDiscardedBrowsingContext& aFrameContext,
ManagedEndpoint<::mozilla::dom::PBrowserBridgeChild>&& aEndpoint,
const TabId& aTabId,
const LayersId& aLayersId) -> RefPtr<MakeFrameRemotePromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendMakeFrameRemote(std::move(aFrameContext), std::move(aEndpoint), std::move(aTabId), std::move(aLayersId), [promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PWindowGlobalParent::SendDrawSnapshot(
const mozilla::Maybe<IntRect>& aRect,
const float& aScale,
const nscolor& aBackgroundColor,
const uint32_t& aFlags,
mozilla::ipc::ResolveCallback<PaintFragment>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_DrawSnapshot(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aRect);
// Sentinel = 'aRect'
((&(writer__)))->WriteSentinel(94044656);
IPC::WriteParam((&(writer__)), aScale);
// Sentinel = 'aScale'
((&(writer__)))->WriteSentinel(131531338);
IPC::WriteParam((&(writer__)), aBackgroundColor);
// Sentinel = 'aBackgroundColor'
((&(writer__)))->WriteSentinel(884999777);
IPC::WriteParam((&(writer__)), aFlags);
// Sentinel = 'aFlags'
((&(writer__)))->WriteSentinel(129892943);
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_DrawSnapshot", OTHER);
ChannelSend(std::move(msg__), PWindowGlobal::Reply_DrawSnapshot__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PWindowGlobalParent::SendDrawSnapshot(
const mozilla::Maybe<IntRect>& aRect,
const float& aScale,
const nscolor& aBackgroundColor,
const uint32_t& aFlags) -> RefPtr<DrawSnapshotPromise>
{
RefPtr<MozPromise<PaintFragment, ResponseRejectReason, true>::Private> promise__ = new MozPromise<PaintFragment, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendDrawSnapshot(std::move(aRect), std::move(aScale), std::move(aBackgroundColor), std::move(aFlags), [promise__](PaintFragment&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PWindowGlobalParent::SendDispatchSecurityPolicyViolation(const nsAString& aViolationEventJSON) -> bool
{
UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_DispatchSecurityPolicyViolation(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aViolationEventJSON);
// Sentinel = 'aViolationEventJSON'
((&(writer__)))->WriteSentinel(1266878291);
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_DispatchSecurityPolicyViolation", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PWindowGlobalParent::SendSaveStorageAccessPermissionGranted() -> bool
{
UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_SaveStorageAccessPermissionGranted(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SaveStorageAccessPermissionGranted", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PWindowGlobalParent::SendAddBlockedFrameNodeByClassifier(const MaybeDiscardedBrowsingContext& aNode) -> bool
{
UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_AddBlockedFrameNodeByClassifier(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aNode);
// Sentinel = 'aNode'
((&(writer__)))->WriteSentinel(94110184);
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_AddBlockedFrameNodeByClassifier", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PWindowGlobalParent::SendResetScalingZoom() -> bool
{
UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_ResetScalingZoom(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_ResetScalingZoom", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PWindowGlobalParent::SendSetContainerFeaturePolicy(FeaturePolicy* aContainerFeaturePolicy) -> bool
{
UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_SetContainerFeaturePolicy(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aContainerFeaturePolicy);
// Sentinel = 'aContainerFeaturePolicy'
((&(writer__)))->WriteSentinel(1834158401);
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SetContainerFeaturePolicy", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PWindowGlobalParent::SendRestoreDocShellState(
const DocShellRestoreState& aState,
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_RestoreDocShellState(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aState);
// Sentinel = 'aState'
((&(writer__)))->WriteSentinel(137036387);
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RestoreDocShellState", OTHER);
ChannelSend(std::move(msg__), PWindowGlobal::Reply_RestoreDocShellState__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PWindowGlobalParent::SendRestoreDocShellState(const DocShellRestoreState& aState) -> RefPtr<RestoreDocShellStatePromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendRestoreDocShellState(std::move(aState), [promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PWindowGlobalParent::SendRestoreTabContent(
SessionStoreRestoreData* aData,
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_RestoreTabContent(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), aData);
// Sentinel = 'aData'
((&(writer__)))->WriteSentinel(90571228);
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RestoreTabContent", OTHER);
ChannelSend(std::move(msg__), PWindowGlobal::Reply_RestoreTabContent__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PWindowGlobalParent::SendRestoreTabContent(SessionStoreRestoreData* aData) -> RefPtr<RestoreTabContentPromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendRestoreTabContent(std::move(aData), [promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PWindowGlobalParent::SendRawMessage(
const JSActorMessageMeta& aMetadata,
const mozilla::Maybe<ClonedMessageData>& aData,
const mozilla::Maybe<ClonedMessageData>& aStack) -> bool
{
UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_RawMessage(Id());
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("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RawMessage", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PWindowGlobalParent::SendNotifyPermissionChange(
const nsACString& type,
const uint32_t& permission) -> bool
{
UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_NotifyPermissionChange(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), type);
// Sentinel = 'type'
((&(writer__)))->WriteSentinel(75760067);
IPC::WriteParam((&(writer__)), permission);
// Sentinel = 'permission'
((&(writer__)))->WriteSentinel(394921034);
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_NotifyPermissionChange", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PWindowGlobalParent::RemoveManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
FatalError("unreached");
return;
}
auto PWindowGlobalParent::DeallocManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
FatalError("unreached");
return;
}
auto PWindowGlobalParent::OnMessageReceived(const Message& msg__) -> PWindowGlobalParent::Result
{
switch (msg__.type()) {
case MANAGED_ENDPOINT_BOUND_MESSAGE_TYPE:
{
if (!mAwaitingManagedEndpointBind) {
NS_WARNING("Unexpected managed endpoint lifecycle message after actor bound!");
return MsgNotAllowed;
}
mAwaitingManagedEndpointBind = false;
return MsgProcessed;
}
case MANAGED_ENDPOINT_DROPPED_MESSAGE_TYPE:
{
if (!mAwaitingManagedEndpointBind) {
NS_WARNING("Unexpected managed endpoint lifecycle message after actor bound!");
return MsgNotAllowed;
}
mAwaitingManagedEndpointBind = false;
this->ActorDisconnected(ManagedEndpointDropped);
return MsgProcessed;
}
case PWindowGlobal::Reply___delete____ID:
{
return MsgProcessed;
}
case PWindowGlobal::Reply_MakeFrameRemote__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_MakeFrameRemote", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<bool> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__success = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__success) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& success = *maybe__success;
// Sentinel = 'success'
if ((!(((&(reader__)))->ReadSentinel(200082170)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(success));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PWindowGlobal::Reply_DrawSnapshot__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_DrawSnapshot", 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<PaintFragment> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__retval = IPC::ReadParam<PaintFragment>((&(reader__)));
if (!maybe__retval) {
FatalError("Error deserializing 'PaintFragment'");
return MsgValueError;
}
auto& retval = *maybe__retval;
// Sentinel = 'retval'
if ((!(((&(reader__)))->ReadSentinel(151716495)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PaintFragment'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(retval));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PWindowGlobal::Reply_RestoreDocShellState__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RestoreDocShellState", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<bool> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__success = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__success) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& success = *maybe__success;
// Sentinel = 'success'
if ((!(((&(reader__)))->ReadSentinel(200082170)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(success));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PWindowGlobal::Reply_RestoreTabContent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RestoreTabContent", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<bool> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__success = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__success) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& success = *maybe__success;
// Sentinel = 'success'
if ((!(((&(reader__)))->ReadSentinel(200082170)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(success));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PWindowGlobal::Msg_RawMessage__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::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<WindowGlobalParent*>(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 PWindowGlobal::Msg_LoadURI__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_LoadURI", OTHER);
IPC::MessageReader reader__{
msg__,
this};
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(287245134)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
return MsgValueError;
}
auto maybe__aLoadState = IPC::ReadParam<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>((&(reader__)));
if (!maybe__aLoadState) {
FatalError("Error deserializing 'NotNull<nsDocShellLoadState>'");
return MsgValueError;
}
auto& aLoadState = *maybe__aLoadState;
// Sentinel = 'aLoadState'
if ((!(((&(reader__)))->ReadSentinel(349570019)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsDocShellLoadState>'");
return MsgValueError;
}
auto maybe__aSetNavigating = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aSetNavigating) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aSetNavigating = *maybe__aSetNavigating;
// Sentinel = 'aSetNavigating'
if ((!(((&(reader__)))->ReadSentinel(686556566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvLoadURI(std::move(aTargetBC), aLoadState, std::move(aSetNavigating));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_InternalLoad__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_InternalLoad", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aLoadState = IPC::ReadParam<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>((&(reader__)));
if (!maybe__aLoadState) {
FatalError("Error deserializing 'NotNull<nsDocShellLoadState>'");
return MsgValueError;
}
auto& aLoadState = *maybe__aLoadState;
// Sentinel = 'aLoadState'
if ((!(((&(reader__)))->ReadSentinel(349570019)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsDocShellLoadState>'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvInternalLoad(aLoadState);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_UpdateDocumentURI__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateDocumentURI", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aUri = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIURI>>>((&(reader__)));
if (!maybe__aUri) {
FatalError("Error deserializing 'NotNull<nsIURI>'");
return MsgValueError;
}
auto& aUri = *maybe__aUri;
// Sentinel = 'aUri'
if ((!(((&(reader__)))->ReadSentinel(64225682)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIURI>'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvUpdateDocumentURI(aUri);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_UpdateDocumentPrincipal__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateDocumentPrincipal", 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;
}
auto maybe__aStoragePrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
if (!maybe__aStoragePrincipal) {
FatalError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
auto& aStoragePrincipal = *maybe__aStoragePrincipal;
// Sentinel = 'aStoragePrincipal'
if ((!(((&(reader__)))->ReadSentinel(1026098905)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvUpdateDocumentPrincipal(aPrincipal, aStoragePrincipal);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_UpdateDocumentHasLoaded__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateDocumentHasLoaded", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aDocumentHasLoaded = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aDocumentHasLoaded) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aDocumentHasLoaded = *maybe__aDocumentHasLoaded;
// Sentinel = 'aDocumentHasLoaded'
if ((!(((&(reader__)))->ReadSentinel(1117259526)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvUpdateDocumentHasLoaded(std::move(aDocumentHasLoaded));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_UpdateDocumentHasUserInteracted__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateDocumentHasUserInteracted", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aDocumentHasUserInteracted = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aDocumentHasUserInteracted) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aDocumentHasUserInteracted = *maybe__aDocumentHasUserInteracted;
// Sentinel = 'aDocumentHasUserInteracted'
if ((!(((&(reader__)))->ReadSentinel(2324695647)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvUpdateDocumentHasUserInteracted(std::move(aDocumentHasUserInteracted));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_UpdateSandboxFlags__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateSandboxFlags", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aSandboxFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aSandboxFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aSandboxFlags = *maybe__aSandboxFlags;
// Sentinel = 'aSandboxFlags'
if ((!(((&(reader__)))->ReadSentinel(590611742)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvUpdateSandboxFlags(std::move(aSandboxFlags));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_UpdateDocumentCspSettings__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateDocumentCspSettings", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aBlockAllMixedContent = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aBlockAllMixedContent) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aBlockAllMixedContent = *maybe__aBlockAllMixedContent;
// Sentinel = 'aBlockAllMixedContent'
if ((!(((&(reader__)))->ReadSentinel(1473906744)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aUpgradeInsecureRequests = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aUpgradeInsecureRequests) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aUpgradeInsecureRequests = *maybe__aUpgradeInsecureRequests;
// Sentinel = 'aUpgradeInsecureRequests'
if ((!(((&(reader__)))->ReadSentinel(2002848196)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvUpdateDocumentCspSettings(std::move(aBlockAllMixedContent), std::move(aUpgradeInsecureRequests));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_UpdateCookieJarSettings__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateCookieJarSettings", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__cookieJarSettings = IPC::ReadParam<CookieJarSettingsArgs>((&(reader__)));
if (!maybe__cookieJarSettings) {
FatalError("Error deserializing 'CookieJarSettingsArgs'");
return MsgValueError;
}
auto& cookieJarSettings = *maybe__cookieJarSettings;
// Sentinel = 'cookieJarSettings'
if ((!(((&(reader__)))->ReadSentinel(1031800553)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CookieJarSettingsArgs'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvUpdateCookieJarSettings(std::move(cookieJarSettings));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_UpdateDocumentTitle__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateDocumentTitle", OTHER);
IPC::MessageReader reader__{
msg__,
this};
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<WindowGlobalParent*>(this))->RecvUpdateDocumentTitle(std::move(aTitle));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_UpdateDocumentSecurityInfo__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateDocumentSecurityInfo", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aSecurityInfo = IPC::ReadParam<RefPtr<nsITransportSecurityInfo>>((&(reader__)));
if (!maybe__aSecurityInfo) {
FatalError("Error deserializing 'nsITransportSecurityInfo'");
return MsgValueError;
}
auto& aSecurityInfo = *maybe__aSecurityInfo;
// Sentinel = 'aSecurityInfo'
if ((!(((&(reader__)))->ReadSentinel(610075974)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsITransportSecurityInfo'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvUpdateDocumentSecurityInfo(aSecurityInfo);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_UpdateHttpsOnlyStatus__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateHttpsOnlyStatus", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aHttpsOnlyStatus = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aHttpsOnlyStatus) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aHttpsOnlyStatus = *maybe__aHttpsOnlyStatus;
// Sentinel = 'aHttpsOnlyStatus'
if ((!(((&(reader__)))->ReadSentinel(920323739)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvUpdateHttpsOnlyStatus(std::move(aHttpsOnlyStatus));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_SetIsInitialDocument__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SetIsInitialDocument", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aIsInitialDocument = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aIsInitialDocument) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aIsInitialDocument = *maybe__aIsInitialDocument;
// Sentinel = 'aIsInitialDocument'
if ((!(((&(reader__)))->ReadSentinel(1108150055)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvSetIsInitialDocument(std::move(aIsInitialDocument));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_Share__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_Share", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aData = IPC::ReadParam<IPCWebShareData>((&(reader__)));
if (!maybe__aData) {
FatalError("Error deserializing 'IPCWebShareData'");
return MsgValueError;
}
auto& aData = *maybe__aData;
// Sentinel = 'aData'
if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCWebShareData'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PWindowGlobal::Reply_Share(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
ShareResolver resolver = [resolver__ = std::move(resolver__)](const nsresult& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'rv'
((&(writer__)))->WriteSentinel(22806761);
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvShare(std::move(aData), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_GetContentBlockingEvents__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_GetContentBlockingEvents", OTHER);
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PWindowGlobal::Reply_GetContentBlockingEvents(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
GetContentBlockingEventsResolver resolver = [resolver__ = std::move(resolver__)](const uint32_t& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'events'
((&(writer__)))->WriteSentinel(149619350);
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvGetContentBlockingEvents(std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_SetClientInfo__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SetClientInfo", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aClientInfo = IPC::ReadParam<IPCClientInfo>((&(reader__)));
if (!maybe__aClientInfo) {
FatalError("Error deserializing 'IPCClientInfo'");
return MsgValueError;
}
auto& aClientInfo = *maybe__aClientInfo;
// Sentinel = 'aClientInfo'
if ((!(((&(reader__)))->ReadSentinel(422315085)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCClientInfo'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvSetClientInfo(std::move(aClientInfo));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_CheckPermitUnload__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_CheckPermitUnload", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aHasInProcessBlocker = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aHasInProcessBlocker) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aHasInProcessBlocker = *maybe__aHasInProcessBlocker;
// Sentinel = 'aHasInProcessBlocker'
if ((!(((&(reader__)))->ReadSentinel(1345652694)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aAction = IPC::ReadParam<XPCOMPermitUnloadAction>((&(reader__)));
if (!maybe__aAction) {
FatalError("Error deserializing 'XPCOMPermitUnloadAction'");
return MsgValueError;
}
auto& aAction = *maybe__aAction;
// Sentinel = 'aAction'
if ((!(((&(reader__)))->ReadSentinel(175768256)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'XPCOMPermitUnloadAction'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PWindowGlobal::Reply_CheckPermitUnload(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
CheckPermitUnloadResolver 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 = 'permitUnload'
((&(writer__)))->WriteSentinel(547816693);
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvCheckPermitUnload(std::move(aHasInProcessBlocker), std::move(aAction), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_ExpectPageUseCounters__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_ExpectPageUseCounters", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aTop = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
if (!maybe__aTop) {
FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
auto& aTop = *maybe__aTop;
// Sentinel = 'aTop'
if ((!(((&(reader__)))->ReadSentinel(64094613)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvExpectPageUseCounters(std::move(aTop));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_AccumulatePageUseCounters__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_AccumulatePageUseCounters", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aUseCounters = IPC::ReadParam<UseCounters>((&(reader__)));
if (!maybe__aUseCounters) {
FatalError("Error deserializing 'UseCounters'");
return MsgValueError;
}
auto& aUseCounters = *maybe__aUseCounters;
// Sentinel = 'aUseCounters'
if ((!(((&(reader__)))->ReadSentinel(514131170)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'UseCounters'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvAccumulatePageUseCounters(std::move(aUseCounters));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_RequestRestoreTabContent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RequestRestoreTabContent", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvRequestRestoreTabContent();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_UpdateBFCacheStatus__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateBFCacheStatus", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aOnFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aOnFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aOnFlags = *maybe__aOnFlags;
// Sentinel = 'aOnFlags'
if ((!(((&(reader__)))->ReadSentinel(222233356)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aOffFlags = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__aOffFlags) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& aOffFlags = *maybe__aOffFlags;
// Sentinel = 'aOffFlags'
if ((!(((&(reader__)))->ReadSentinel(277480298)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvUpdateBFCacheStatus(std::move(aOnFlags), std::move(aOffFlags));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_UpdateActivePeerConnectionStatus__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateActivePeerConnectionStatus", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aIsAdded = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aIsAdded) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aIsAdded = *maybe__aIsAdded;
// Sentinel = 'aIsAdded'
if ((!(((&(reader__)))->ReadSentinel(217055984)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvUpdateActivePeerConnectionStatus(std::move(aIsAdded));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_SetSingleChannelId__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SetSingleChannelId", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__singleChannelId = IPC::ReadParam<mozilla::Maybe<uint64_t>>((&(reader__)));
if (!maybe__singleChannelId) {
FatalError("Error deserializing 'uint64_t?'");
return MsgValueError;
}
auto& singleChannelId = *maybe__singleChannelId;
// Sentinel = 'singleChannelId'
if ((!(((&(reader__)))->ReadSentinel(810812905)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t?'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvSetSingleChannelId(std::move(singleChannelId));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_SetDocumentDomain__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SetDocumentDomain", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aDomain = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIURI>>>((&(reader__)));
if (!maybe__aDomain) {
FatalError("Error deserializing 'NotNull<nsIURI>'");
return MsgValueError;
}
auto& aDomain = *maybe__aDomain;
// Sentinel = 'aDomain'
if ((!(((&(reader__)))->ReadSentinel(176685754)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIURI>'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvSetDocumentDomain(aDomain);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_Destroy__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_Destroy", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvDestroy();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_ReloadWithHttpsOnlyException__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_ReloadWithHttpsOnlyException", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvReloadWithHttpsOnlyException();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_DiscoverIdentityCredentialFromExternalSource__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_DiscoverIdentityCredentialFromExternalSource", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aOptions = IPC::ReadParam<IdentityCredentialRequestOptions>((&(reader__)));
if (!maybe__aOptions) {
FatalError("Error deserializing 'IdentityCredentialRequestOptions'");
return MsgValueError;
}
auto& aOptions = *maybe__aOptions;
// Sentinel = 'aOptions'
if ((!(((&(reader__)))->ReadSentinel(240976718)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IdentityCredentialRequestOptions'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PWindowGlobal::Reply_DiscoverIdentityCredentialFromExternalSource(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
DiscoverIdentityCredentialFromExternalSourceResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<IPCIdentityCredential>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'identityCredential'
((&(writer__)))->WriteSentinel(1181419366);
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvDiscoverIdentityCredentialFromExternalSource(std::move(aOptions), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_GetStorageAccessPermission__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_GetStorageAccessPermission", OTHER);
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PWindowGlobal::Reply_GetStorageAccessPermission(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
GetStorageAccessPermissionResolver resolver = [resolver__ = std::move(resolver__)](const uint32_t& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'permission_action'
((&(writer__)))->WriteSentinel(1085605671);
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvGetStorageAccessPermission(std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_SetCookies__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SetCookies", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__baseDomain = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__baseDomain) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& baseDomain = *maybe__baseDomain;
// Sentinel = 'baseDomain'
if ((!(((&(reader__)))->ReadSentinel(360449012)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto maybe__attrs = IPC::ReadParam<OriginAttributes>((&(reader__)));
if (!maybe__attrs) {
FatalError("Error deserializing 'OriginAttributes'");
return MsgValueError;
}
auto& attrs = *maybe__attrs;
// Sentinel = 'attrs'
if ((!(((&(reader__)))->ReadSentinel(107807279)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributes'");
return MsgValueError;
}
auto maybe__host = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__host) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& host = *maybe__host;
// Sentinel = 'host'
if ((!(((&(reader__)))->ReadSentinel(72024511)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__fromHttp = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__fromHttp) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& fromHttp = *maybe__fromHttp;
// Sentinel = 'fromHttp'
if ((!(((&(reader__)))->ReadSentinel(249889621)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__cookies = IPC::ReadParam<nsTArray<CookieStruct>>((&(reader__)));
if (!maybe__cookies) {
FatalError("Error deserializing 'CookieStruct[]'");
return MsgValueError;
}
auto& cookies = *maybe__cookies;
// Sentinel = 'cookies'
if ((!(((&(reader__)))->ReadSentinel(195363566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CookieStruct[]'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvSetCookies(std::move(baseDomain), std::move(attrs), host, std::move(fromHttp), std::move(cookies));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PWindowGlobal::Msg_OnInitialStorageAccess__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PWindowGlobalParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PWindowGlobal::Msg_OnInitialStorageAccess", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvOnInitialStorageAccess();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
default:
return MsgNotKnown;
}
}
auto PWindowGlobalParent::OnMessageReceived(
const Message& msg__,
UniquePtr<Message>& reply__) -> PWindowGlobalParent::Result
{
return MsgNotKnown;
}
auto PWindowGlobalParent::DoomSubtree() -> void
{
SetDoomed();
}
auto PWindowGlobalParent::PeekManagedActor() -> IProtocol*
{
return nullptr;
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::PWindowGlobalParent*>::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::PWindowGlobalParent*>::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, "PWindowGlobal", PWindowGlobalMsgStart);
if (actor.isSome()) {
return static_cast<::mozilla::dom::PWindowGlobalParent*>(actor.ref());
}
return {};
}
} // namespace IPC