Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "mozilla/dom/ServiceWorkerIPCUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/FeaturePolicyUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/net/CacheInfoIPCTypes.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/net/ClassOfService.h"
#include "mozilla/net/HttpChannelParams.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"
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct HttpChannelOnStartRequestArgs|
//
namespace mozilla {
namespace net {
auto HttpChannelOnStartRequestArgs::StaticAssertions() const -> void
{
static_assert(
(offsetof(HttpChannelOnStartRequestArgs, altDataLength_) - offsetof(HttpChannelOnStartRequestArgs, cacheEntryId_)) == 8,
"Bad assumptions about field layout!");
static_assert(
(offsetof(HttpChannelOnStartRequestArgs, cacheKey_) - offsetof(HttpChannelOnStartRequestArgs, cacheFetchCount_)) == 8,
"Bad assumptions about field layout!");
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::HttpChannelOnStartRequestArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).securityInfo());
// Sentinel = 'securityInfo'
(aWriter)->WriteSentinel(552535301);
IPC::WriteParam(aWriter, (aVar).overrideReferrerInfo());
// Sentinel = 'overrideReferrerInfo'
(aWriter)->WriteSentinel(1454704682);
IPC::WriteParam(aWriter, (aVar).altDataType());
// Sentinel = 'altDataType'
(aWriter)->WriteSentinel(434504798);
IPC::WriteParam(aWriter, (aVar).cookie());
// Sentinel = 'cookie'
(aWriter)->WriteSentinel(146211451);
IPC::WriteParam(aWriter, (aVar).selfAddr());
// Sentinel = 'selfAddr'
(aWriter)->WriteSentinel(240321318);
IPC::WriteParam(aWriter, (aVar).peerAddr());
// Sentinel = 'peerAddr'
(aWriter)->WriteSentinel(239928104);
IPC::WriteParam(aWriter, (aVar).timing());
// Sentinel = 'timing'
(aWriter)->WriteSentinel(150798985);
IPC::WriteParam(aWriter, (aVar).loadInfoForwarder());
// Sentinel = 'loadInfoForwarder'
(aWriter)->WriteSentinel(1020528345);
IPC::WriteParam(aWriter, (aVar).channelStatus());
// Sentinel = 'channelStatus'
(aWriter)->WriteSentinel(618136926);
IPC::WriteParam(aWriter, (aVar).effectiveTRRMode());
// Sentinel = 'effectiveTRRMode'
(aWriter)->WriteSentinel(899089967);
IPC::WriteParam(aWriter, (aVar).trrSkipReason());
// Sentinel = 'trrSkipReason'
(aWriter)->WriteSentinel(630588760);
IPC::WriteParam(aWriter, (aVar).multiPartID());
// Sentinel = 'multiPartID'
(aWriter)->WriteSentinel(458622032);
IPC::WriteParam(aWriter, (aVar).isFromCache());
// Sentinel = 'isFromCache'
(aWriter)->WriteSentinel(433718341);
IPC::WriteParam(aWriter, (aVar).isRacing());
// Sentinel = 'isRacing'
(aWriter)->WriteSentinel(240124721);
IPC::WriteParam(aWriter, (aVar).cacheEntryAvailable());
// Sentinel = 'cacheEntryAvailable'
(aWriter)->WriteSentinel(1254164360);
IPC::WriteParam(aWriter, (aVar).deliveringAltData());
// Sentinel = 'deliveringAltData'
(aWriter)->WriteSentinel(1039533765);
IPC::WriteParam(aWriter, (aVar).applyConversion());
// Sentinel = 'applyConversion'
(aWriter)->WriteSentinel(837486157);
IPC::WriteParam(aWriter, (aVar).isResolvedByTRR());
// Sentinel = 'isResolvedByTRR'
(aWriter)->WriteSentinel(811861460);
IPC::WriteParam(aWriter, (aVar).allRedirectsSameOrigin());
// Sentinel = 'allRedirectsSameOrigin'
(aWriter)->WriteSentinel(1689716941);
IPC::WriteParam(aWriter, (aVar).isFirstPartOfMultiPart());
// Sentinel = 'isFirstPartOfMultiPart'
(aWriter)->WriteSentinel(1696532691);
IPC::WriteParam(aWriter, (aVar).isLastPartOfMultiPart());
// Sentinel = 'isLastPartOfMultiPart'
(aWriter)->WriteSentinel(1534134367);
IPC::WriteParam(aWriter, (aVar).openerPolicy());
// Sentinel = 'openerPolicy'
(aWriter)->WriteSentinel(542835962);
IPC::WriteParam(aWriter, (aVar).shouldWaitForOnStartRequestSent());
// Sentinel = 'shouldWaitForOnStartRequestSent'
(aWriter)->WriteSentinel(3372354714);
IPC::WriteParam(aWriter, (aVar).dataFromSocketProcess());
// Sentinel = 'dataFromSocketProcess'
(aWriter)->WriteSentinel(1537869943);
IPC::WriteParam(aWriter, (aVar).hasHTTPSRR());
// Sentinel = 'hasHTTPSRR'
(aWriter)->WriteSentinel(333316980);
IPC::WriteParam(aWriter, (aVar).isProxyUsed());
// Sentinel = 'isProxyUsed'
(aWriter)->WriteSentinel(461178000);
IPC::WriteParam(aWriter, (aVar).protocolVersion());
// Sentinel = 'protocolVersion'
(aWriter)->WriteSentinel(857540185);
(aWriter)->WriteBytes((&((aVar).cacheEntryId())), 16);
// Sentinel = 'cacheEntryId | altDataLength'
(aWriter)->WriteSentinel(2550139533);
(aWriter)->WriteBytes((&((aVar).cacheFetchCount())), 12);
// Sentinel = 'cacheFetchCount | cacheExpirationTime | cacheKey'
(aWriter)->WriteSentinel(3181515299);
(aWriter)->WriteBytes((&((aVar).redirectCount())), 1);
// Sentinel = 'redirectCount'
(aWriter)->WriteSentinel(625608028);
}
auto ParamTraits<::mozilla::net::HttpChannelOnStartRequestArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___securityInfo = IPC::ReadParam<RefPtr<::nsITransportSecurityInfo>>(aReader);
if (!maybe___securityInfo) {
aReader->FatalError("Error deserializing 'securityInfo' (nsITransportSecurityInfo) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _securityInfo = *maybe___securityInfo;
// Sentinel = 'securityInfo'
if ((!((aReader)->ReadSentinel(552535301)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'securityInfo' (nsITransportSecurityInfo) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___overrideReferrerInfo = IPC::ReadParam<RefPtr<::nsIReferrerInfo>>(aReader);
if (!maybe___overrideReferrerInfo) {
aReader->FatalError("Error deserializing 'overrideReferrerInfo' (nsIReferrerInfo) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _overrideReferrerInfo = *maybe___overrideReferrerInfo;
// Sentinel = 'overrideReferrerInfo'
if ((!((aReader)->ReadSentinel(1454704682)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'overrideReferrerInfo' (nsIReferrerInfo) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___altDataType = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___altDataType) {
aReader->FatalError("Error deserializing 'altDataType' (nsCString) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _altDataType = *maybe___altDataType;
// Sentinel = 'altDataType'
if ((!((aReader)->ReadSentinel(434504798)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'altDataType' (nsCString) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___cookie = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___cookie) {
aReader->FatalError("Error deserializing 'cookie' (nsCString) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _cookie = *maybe___cookie;
// Sentinel = 'cookie'
if ((!((aReader)->ReadSentinel(146211451)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cookie' (nsCString) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___selfAddr = IPC::ReadParam<::mozilla::net::NetAddr>(aReader);
if (!maybe___selfAddr) {
aReader->FatalError("Error deserializing 'selfAddr' (NetAddr) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _selfAddr = *maybe___selfAddr;
// Sentinel = 'selfAddr'
if ((!((aReader)->ReadSentinel(240321318)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'selfAddr' (NetAddr) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___peerAddr = IPC::ReadParam<::mozilla::net::NetAddr>(aReader);
if (!maybe___peerAddr) {
aReader->FatalError("Error deserializing 'peerAddr' (NetAddr) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _peerAddr = *maybe___peerAddr;
// Sentinel = 'peerAddr'
if ((!((aReader)->ReadSentinel(239928104)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'peerAddr' (NetAddr) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___timing = IPC::ReadParam<::mozilla::net::ResourceTimingStructArgs>(aReader);
if (!maybe___timing) {
aReader->FatalError("Error deserializing 'timing' (ResourceTimingStructArgs) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _timing = *maybe___timing;
// Sentinel = 'timing'
if ((!((aReader)->ReadSentinel(150798985)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'timing' (ResourceTimingStructArgs) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___loadInfoForwarder = IPC::ReadParam<::mozilla::net::ParentLoadInfoForwarderArgs>(aReader);
if (!maybe___loadInfoForwarder) {
aReader->FatalError("Error deserializing 'loadInfoForwarder' (ParentLoadInfoForwarderArgs) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _loadInfoForwarder = *maybe___loadInfoForwarder;
// Sentinel = 'loadInfoForwarder'
if ((!((aReader)->ReadSentinel(1020528345)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'loadInfoForwarder' (ParentLoadInfoForwarderArgs) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___channelStatus = IPC::ReadParam<::nsresult>(aReader);
if (!maybe___channelStatus) {
aReader->FatalError("Error deserializing 'channelStatus' (nsresult) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _channelStatus = *maybe___channelStatus;
// Sentinel = 'channelStatus'
if ((!((aReader)->ReadSentinel(618136926)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'channelStatus' (nsresult) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___effectiveTRRMode = IPC::ReadParam<::nsIRequest::TRRMode>(aReader);
if (!maybe___effectiveTRRMode) {
aReader->FatalError("Error deserializing 'effectiveTRRMode' (TRRMode) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _effectiveTRRMode = *maybe___effectiveTRRMode;
// Sentinel = 'effectiveTRRMode'
if ((!((aReader)->ReadSentinel(899089967)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'effectiveTRRMode' (TRRMode) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___trrSkipReason = IPC::ReadParam<::mozilla::net::TRRSkippedReason>(aReader);
if (!maybe___trrSkipReason) {
aReader->FatalError("Error deserializing 'trrSkipReason' (TRRSkippedReason) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _trrSkipReason = *maybe___trrSkipReason;
// Sentinel = 'trrSkipReason'
if ((!((aReader)->ReadSentinel(630588760)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'trrSkipReason' (TRRSkippedReason) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___multiPartID = IPC::ReadParam<mozilla::Maybe<::uint32_t>>(aReader);
if (!maybe___multiPartID) {
aReader->FatalError("Error deserializing 'multiPartID' (uint32_t?) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _multiPartID = *maybe___multiPartID;
// Sentinel = 'multiPartID'
if ((!((aReader)->ReadSentinel(458622032)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'multiPartID' (uint32_t?) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___isFromCache = IPC::ReadParam<bool>(aReader);
if (!maybe___isFromCache) {
aReader->FatalError("Error deserializing 'isFromCache' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _isFromCache = *maybe___isFromCache;
// Sentinel = 'isFromCache'
if ((!((aReader)->ReadSentinel(433718341)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isFromCache' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___isRacing = IPC::ReadParam<bool>(aReader);
if (!maybe___isRacing) {
aReader->FatalError("Error deserializing 'isRacing' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _isRacing = *maybe___isRacing;
// Sentinel = 'isRacing'
if ((!((aReader)->ReadSentinel(240124721)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isRacing' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___cacheEntryAvailable = IPC::ReadParam<bool>(aReader);
if (!maybe___cacheEntryAvailable) {
aReader->FatalError("Error deserializing 'cacheEntryAvailable' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _cacheEntryAvailable = *maybe___cacheEntryAvailable;
// Sentinel = 'cacheEntryAvailable'
if ((!((aReader)->ReadSentinel(1254164360)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cacheEntryAvailable' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___deliveringAltData = IPC::ReadParam<bool>(aReader);
if (!maybe___deliveringAltData) {
aReader->FatalError("Error deserializing 'deliveringAltData' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _deliveringAltData = *maybe___deliveringAltData;
// Sentinel = 'deliveringAltData'
if ((!((aReader)->ReadSentinel(1039533765)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'deliveringAltData' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___applyConversion = IPC::ReadParam<bool>(aReader);
if (!maybe___applyConversion) {
aReader->FatalError("Error deserializing 'applyConversion' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _applyConversion = *maybe___applyConversion;
// Sentinel = 'applyConversion'
if ((!((aReader)->ReadSentinel(837486157)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'applyConversion' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___isResolvedByTRR = IPC::ReadParam<bool>(aReader);
if (!maybe___isResolvedByTRR) {
aReader->FatalError("Error deserializing 'isResolvedByTRR' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _isResolvedByTRR = *maybe___isResolvedByTRR;
// Sentinel = 'isResolvedByTRR'
if ((!((aReader)->ReadSentinel(811861460)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isResolvedByTRR' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___allRedirectsSameOrigin = IPC::ReadParam<bool>(aReader);
if (!maybe___allRedirectsSameOrigin) {
aReader->FatalError("Error deserializing 'allRedirectsSameOrigin' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _allRedirectsSameOrigin = *maybe___allRedirectsSameOrigin;
// Sentinel = 'allRedirectsSameOrigin'
if ((!((aReader)->ReadSentinel(1689716941)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allRedirectsSameOrigin' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___isFirstPartOfMultiPart = IPC::ReadParam<bool>(aReader);
if (!maybe___isFirstPartOfMultiPart) {
aReader->FatalError("Error deserializing 'isFirstPartOfMultiPart' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _isFirstPartOfMultiPart = *maybe___isFirstPartOfMultiPart;
// Sentinel = 'isFirstPartOfMultiPart'
if ((!((aReader)->ReadSentinel(1696532691)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isFirstPartOfMultiPart' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___isLastPartOfMultiPart = IPC::ReadParam<bool>(aReader);
if (!maybe___isLastPartOfMultiPart) {
aReader->FatalError("Error deserializing 'isLastPartOfMultiPart' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _isLastPartOfMultiPart = *maybe___isLastPartOfMultiPart;
// Sentinel = 'isLastPartOfMultiPart'
if ((!((aReader)->ReadSentinel(1534134367)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isLastPartOfMultiPart' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___openerPolicy = IPC::ReadParam<::nsILoadInfo::CrossOriginOpenerPolicy>(aReader);
if (!maybe___openerPolicy) {
aReader->FatalError("Error deserializing 'openerPolicy' (CrossOriginOpenerPolicy) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _openerPolicy = *maybe___openerPolicy;
// Sentinel = 'openerPolicy'
if ((!((aReader)->ReadSentinel(542835962)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'openerPolicy' (CrossOriginOpenerPolicy) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___shouldWaitForOnStartRequestSent = IPC::ReadParam<bool>(aReader);
if (!maybe___shouldWaitForOnStartRequestSent) {
aReader->FatalError("Error deserializing 'shouldWaitForOnStartRequestSent' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _shouldWaitForOnStartRequestSent = *maybe___shouldWaitForOnStartRequestSent;
// Sentinel = 'shouldWaitForOnStartRequestSent'
if ((!((aReader)->ReadSentinel(3372354714)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'shouldWaitForOnStartRequestSent' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___dataFromSocketProcess = IPC::ReadParam<bool>(aReader);
if (!maybe___dataFromSocketProcess) {
aReader->FatalError("Error deserializing 'dataFromSocketProcess' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _dataFromSocketProcess = *maybe___dataFromSocketProcess;
// Sentinel = 'dataFromSocketProcess'
if ((!((aReader)->ReadSentinel(1537869943)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'dataFromSocketProcess' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___hasHTTPSRR = IPC::ReadParam<bool>(aReader);
if (!maybe___hasHTTPSRR) {
aReader->FatalError("Error deserializing 'hasHTTPSRR' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _hasHTTPSRR = *maybe___hasHTTPSRR;
// Sentinel = 'hasHTTPSRR'
if ((!((aReader)->ReadSentinel(333316980)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'hasHTTPSRR' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___isProxyUsed = IPC::ReadParam<bool>(aReader);
if (!maybe___isProxyUsed) {
aReader->FatalError("Error deserializing 'isProxyUsed' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _isProxyUsed = *maybe___isProxyUsed;
// Sentinel = 'isProxyUsed'
if ((!((aReader)->ReadSentinel(461178000)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isProxyUsed' (bool) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto maybe___protocolVersion = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___protocolVersion) {
aReader->FatalError("Error deserializing 'protocolVersion' (nsCString) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
auto& _protocolVersion = *maybe___protocolVersion;
// Sentinel = 'protocolVersion'
if ((!((aReader)->ReadSentinel(857540185)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'protocolVersion' (nsCString) member of 'HttpChannelOnStartRequestArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_securityInfo),
std::move(_overrideReferrerInfo),
::uint64_t{0},
::int64_t{0},
std::move(_altDataType),
std::move(_cookie),
std::move(_selfAddr),
std::move(_peerAddr),
std::move(_timing),
std::move(_loadInfoForwarder),
std::move(_channelStatus),
std::move(_effectiveTRRMode),
std::move(_trrSkipReason),
::uint32_t{0},
::uint32_t{0},
::uint32_t{0},
std::move(_multiPartID),
std::move(_isFromCache),
std::move(_isRacing),
std::move(_cacheEntryAvailable),
std::move(_deliveringAltData),
std::move(_applyConversion),
std::move(_isResolvedByTRR),
std::move(_allRedirectsSameOrigin),
std::move(_isFirstPartOfMultiPart),
std::move(_isLastPartOfMultiPart),
std::move(_openerPolicy),
std::move(_shouldWaitForOnStartRequestSent),
std::move(_dataFromSocketProcess),
std::move(_hasHTTPSRR),
std::move(_isProxyUsed),
::uint8_t{0},
std::move(_protocolVersion)};
if ((!((aReader)->ReadBytesInto((&((result__)->cacheEntryId())), 16)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'cacheEntryId | altDataLength'
if ((!((aReader)->ReadSentinel(2550139533)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->cacheFetchCount())), 12)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'cacheFetchCount | cacheExpirationTime | cacheKey'
if ((!((aReader)->ReadSentinel(3181515299)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->redirectCount())), 1)))) {
aReader->FatalError("Error bulk reading fields from uint8_t");
return {};
}
// Sentinel = 'redirectCount'
if ((!((aReader)->ReadSentinel(625608028)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint8_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct HttpChannelAltDataStream|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::HttpChannelAltDataStream>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).altDataInputStream());
// Sentinel = 'altDataInputStream'
(aWriter)->WriteSentinel(1134102328);
}
auto ParamTraits<::mozilla::net::HttpChannelAltDataStream>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___altDataInputStream = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::IPCStream>>(aReader);
if (!maybe___altDataInputStream) {
aReader->FatalError("Error deserializing 'altDataInputStream' (IPCStream?) member of 'HttpChannelAltDataStream'");
return {};
}
auto& _altDataInputStream = *maybe___altDataInputStream;
// Sentinel = 'altDataInputStream'
if ((!((aReader)->ReadSentinel(1134102328)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'altDataInputStream' (IPCStream?) member of 'HttpChannelAltDataStream'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_altDataInputStream)};
return result__;
}
} // namespace IPC