Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/net/PHttpTransactionChild.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/SessionHistoryEntry.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/net/CacheInfoIPCTypes.h"
#include "mozilla/net/ClassOfService.h"
#include "mozilla/net/HttpTransactionChild.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "nsDOMNavigationTiming.h"
#include "nsDocShellLoadState.h"
#include "nsHttp.h"
#include "nsHttpHeaderArray.h"
#include "nsHttpRequestHead.h"
#include "nsHttpResponseHead.h"
#include "nsIPropertyBag2.h"
#include "nsITransportSecurityInfo.h"
#include "mozilla/net/PSocketProcessChild.h"
#include "mozilla/net/PInputChannelThrottleQueueChild.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 net {
auto PHttpTransactionChild::Recv__delete__() -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
MOZ_IMPLICIT PHttpTransactionChild::PHttpTransactionChild() :
mozilla::ipc::IRefCountedProtocol(PHttpTransactionMsgStart, mozilla::ipc::ChildSide)
{
MOZ_COUNT_CTOR(PHttpTransactionChild);
}
PHttpTransactionChild::~PHttpTransactionChild()
{
MOZ_COUNT_DTOR(PHttpTransactionChild);
}
auto PHttpTransactionChild::ActorAlloc() -> void
{
AddRef();
}
auto PHttpTransactionChild::ActorDealloc() -> void
{
Release();
}
auto PHttpTransactionChild::OtherPid() const -> ::base::ProcessId
{
::base::ProcessId pid =
::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherPidMaybeInvalid();
MOZ_RELEASE_ASSERT(pid != ::base::kInvalidProcessId);
return pid;
}
auto PHttpTransactionChild::Manager() const -> PSocketProcessChild*
{
return static_cast<PSocketProcessChild*>(IProtocol::Manager());
}
auto PHttpTransactionChild::AllManagedActorsCount() const -> uint32_t
{
uint32_t total = 0;
return total;
}
auto PHttpTransactionChild::SendOnStartRequest(
const nsresult& status,
const mozilla::Maybe<nsHttpResponseHead>& responseHead,
nsITransportSecurityInfo* securityInfo,
const bool& proxyConnectFailed,
const TimingStructArgs& timings,
const int32_t& proxyConnectResponseCode,
mozilla::Span<uint8_t const> dataForSniffer,
const mozilla::Maybe<nsCString>& altSvcUsed,
const bool& dataToChildProcess,
const bool& restarted,
const uint32_t& HTTPSSVCReceivedStage,
const bool& supportsHttp3,
const TRRMode& trrMode,
const TRRSkippedReason& trrSkipReason,
const uint32_t& caps,
const TimeStamp& onStartRequestStart) -> bool
{
UniquePtr<IPC::Message> msg__ = PHttpTransaction::Msg_OnStartRequest(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), status);
// Sentinel = 'status'
((&(writer__)))->WriteSentinel(154731173);
IPC::WriteParam((&(writer__)), responseHead);
// Sentinel = 'responseHead'
((&(writer__)))->WriteSentinel(549651682);
IPC::WriteParam((&(writer__)), securityInfo);
// Sentinel = 'securityInfo'
((&(writer__)))->WriteSentinel(552535301);
IPC::WriteParam((&(writer__)), proxyConnectFailed);
// Sentinel = 'proxyConnectFailed'
((&(writer__)))->WriteSentinel(1194002258);
IPC::WriteParam((&(writer__)), timings);
// Sentinel = 'timings'
((&(writer__)))->WriteSentinel(200868604);
IPC::WriteParam((&(writer__)), proxyConnectResponseCode);
// Sentinel = 'proxyConnectResponseCode'
((&(writer__)))->WriteSentinel(2099382743);
IPC::WriteParam((&(writer__)), dataForSniffer);
// Sentinel = 'dataForSniffer'
((&(writer__)))->WriteSentinel(690816399);
IPC::WriteParam((&(writer__)), altSvcUsed);
// Sentinel = 'altSvcUsed'
((&(writer__)))->WriteSentinel(370344959);
IPC::WriteParam((&(writer__)), dataToChildProcess);
// Sentinel = 'dataToChildProcess'
((&(writer__)))->WriteSentinel(1114769185);
IPC::WriteParam((&(writer__)), restarted);
// Sentinel = 'restarted'
((&(writer__)))->WriteSentinel(323421135);
IPC::WriteParam((&(writer__)), HTTPSSVCReceivedStage);
// Sentinel = 'HTTPSSVCReceivedStage'
((&(writer__)))->WriteSentinel(1328154523);
IPC::WriteParam((&(writer__)), supportsHttp3);
// Sentinel = 'supportsHttp3'
((&(writer__)))->WriteSentinel(663487844);
IPC::WriteParam((&(writer__)), trrMode);
// Sentinel = 'trrMode'
((&(writer__)))->WriteSentinel(197591774);
IPC::WriteParam((&(writer__)), trrSkipReason);
// Sentinel = 'trrSkipReason'
((&(writer__)))->WriteSentinel(630588760);
IPC::WriteParam((&(writer__)), caps);
// Sentinel = 'caps'
((&(writer__)))->WriteSentinel(67502504);
IPC::WriteParam((&(writer__)), onStartRequestStart);
// Sentinel = 'onStartRequestStart'
((&(writer__)))->WriteSentinel(1313015779);
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg_OnStartRequest", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PHttpTransactionChild::SendOnTransportStatus(
const nsresult& status,
const int64_t& progress,
const int64_t& progressMax,
const mozilla::Maybe<NetworkAddressArg>& networkAddressArg) -> bool
{
UniquePtr<IPC::Message> msg__ = PHttpTransaction::Msg_OnTransportStatus(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), status);
// Sentinel = 'status'
((&(writer__)))->WriteSentinel(154731173);
IPC::WriteParam((&(writer__)), progress);
// Sentinel = 'progress'
((&(writer__)))->WriteSentinel(261292918);
IPC::WriteParam((&(writer__)), progressMax);
// Sentinel = 'progressMax'
((&(writer__)))->WriteSentinel(471205020);
IPC::WriteParam((&(writer__)), networkAddressArg);
// Sentinel = 'networkAddressArg'
((&(writer__)))->WriteSentinel(1062471403);
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg_OnTransportStatus", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PHttpTransactionChild::SendOnDataAvailable(
const nsACString& data,
const uint64_t& offset,
const uint32_t& count,
const TimeStamp& onDataAvailableStart) -> bool
{
UniquePtr<IPC::Message> msg__ = PHttpTransaction::Msg_OnDataAvailable(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), data);
// Sentinel = 'data'
((&(writer__)))->WriteSentinel(67109275);
IPC::WriteParam((&(writer__)), offset);
// Sentinel = 'offset'
((&(writer__)))->WriteSentinel(147653256);
IPC::WriteParam((&(writer__)), count);
// Sentinel = 'count'
((&(writer__)))->WriteSentinel(106889770);
IPC::WriteParam((&(writer__)), onDataAvailableStart);
// Sentinel = 'onDataAvailableStart'
((&(writer__)))->WriteSentinel(1369049063);
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg_OnDataAvailable", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PHttpTransactionChild::SendOnStopRequest(
const nsresult& status,
const bool& responseIsComplete,
const int64_t& transferSize,
const TimingStructArgs& timings,
const mozilla::Maybe<nsHttpHeaderArray>& responseTrailers,
const mozilla::Maybe<TransactionObserverResult>& transactionObserverResult,
const TimeStamp& lastActiveTabOptimization,
const HttpConnectionInfoCloneArgs& connInfoArgs,
const TimeStamp& onStopRequestStart) -> bool
{
UniquePtr<IPC::Message> msg__ = PHttpTransaction::Msg_OnStopRequest(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), status);
// Sentinel = 'status'
((&(writer__)))->WriteSentinel(154731173);
IPC::WriteParam((&(writer__)), responseIsComplete);
// Sentinel = 'responseIsComplete'
((&(writer__)))->WriteSentinel(1188956005);
IPC::WriteParam((&(writer__)), transferSize);
// Sentinel = 'transferSize'
((&(writer__)))->WriteSentinel(551814401);
IPC::WriteParam((&(writer__)), timings);
// Sentinel = 'timings'
((&(writer__)))->WriteSentinel(200868604);
IPC::WriteParam((&(writer__)), responseTrailers);
// Sentinel = 'responseTrailers'
((&(writer__)))->WriteSentinel(961873590);
IPC::WriteParam((&(writer__)), transactionObserverResult);
// Sentinel = 'transactionObserverResult'
((&(writer__)))->WriteSentinel(2271873646);
IPC::WriteParam((&(writer__)), lastActiveTabOptimization);
// Sentinel = 'lastActiveTabOptimization'
((&(writer__)))->WriteSentinel(2190412335);
IPC::WriteParam((&(writer__)), connInfoArgs);
// Sentinel = 'connInfoArgs'
((&(writer__)))->WriteSentinel(521340104);
IPC::WriteParam((&(writer__)), onStopRequestStart);
// Sentinel = 'onStopRequestStart'
((&(writer__)))->WriteSentinel(1183909755);
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg_OnStopRequest", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PHttpTransactionChild::SendOnInitFailed(const nsresult& status) -> bool
{
UniquePtr<IPC::Message> msg__ = PHttpTransaction::Msg_OnInitFailed(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), status);
// Sentinel = 'status'
((&(writer__)))->WriteSentinel(154731173);
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg_OnInitFailed", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PHttpTransactionChild::SendOnH2PushStream(
const uint32_t& pushedStreamId,
const nsACString& resourceUrl,
const nsACString& requestString) -> bool
{
UniquePtr<IPC::Message> msg__ = PHttpTransaction::Msg_OnH2PushStream(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), pushedStreamId);
// Sentinel = 'pushedStreamId'
((&(writer__)))->WriteSentinel(731579811);
IPC::WriteParam((&(writer__)), resourceUrl);
// Sentinel = 'resourceUrl'
((&(writer__)))->WriteSentinel(471270556);
IPC::WriteParam((&(writer__)), requestString);
// Sentinel = 'requestString'
((&(writer__)))->WriteSentinel(650970497);
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg_OnH2PushStream", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PHttpTransactionChild::SendEarlyHint(
const nsACString& linkHeader,
const nsACString& referrerPolicy,
const nsACString& cspHeader) -> bool
{
UniquePtr<IPC::Message> msg__ = PHttpTransaction::Msg_EarlyHint(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), linkHeader);
// Sentinel = 'linkHeader'
((&(writer__)))->WriteSentinel(367330296);
IPC::WriteParam((&(writer__)), referrerPolicy);
// Sentinel = 'referrerPolicy'
((&(writer__)))->WriteSentinel(729482702);
IPC::WriteParam((&(writer__)), cspHeader);
// Sentinel = 'cspHeader'
((&(writer__)))->WriteSentinel(297862032);
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg_EarlyHint", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PHttpTransactionChild::RemoveManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
FatalError("unreached");
return;
}
auto PHttpTransactionChild::DeallocManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
FatalError("unreached");
return;
}
auto PHttpTransactionChild::OnMessageReceived(const Message& msg__) -> PHttpTransactionChild::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 PHttpTransaction::Msg___delete____ID:
{
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg___delete__", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<HttpTransactionChild*>(this))->Recv__delete__();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
this->ActorDisconnected(Deletion);
return MsgProcessed;
}
case PHttpTransaction::Msg_Init__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg_Init", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__caps = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__caps) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& caps = *maybe__caps;
// Sentinel = 'caps'
if ((!(((&(reader__)))->ReadSentinel(67502504)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__aArgs = IPC::ReadParam<HttpConnectionInfoCloneArgs>((&(reader__)));
if (!maybe__aArgs) {
FatalError("Error deserializing 'HttpConnectionInfoCloneArgs'");
return MsgValueError;
}
auto& aArgs = *maybe__aArgs;
// Sentinel = 'aArgs'
if ((!(((&(reader__)))->ReadSentinel(92602863)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'HttpConnectionInfoCloneArgs'");
return MsgValueError;
}
auto maybe__reqHeaders = IPC::ReadParam<nsHttpRequestHead>((&(reader__)));
if (!maybe__reqHeaders) {
FatalError("Error deserializing 'nsHttpRequestHead'");
return MsgValueError;
}
auto& reqHeaders = *maybe__reqHeaders;
// Sentinel = 'reqHeaders'
if ((!(((&(reader__)))->ReadSentinel(367264773)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsHttpRequestHead'");
return MsgValueError;
}
auto maybe__requestBody = IPC::ReadParam<mozilla::Maybe<IPCStream>>((&(reader__)));
if (!maybe__requestBody) {
FatalError("Error deserializing 'IPCStream?'");
return MsgValueError;
}
auto& requestBody = *maybe__requestBody;
// Sentinel = 'requestBody'
if ((!(((&(reader__)))->ReadSentinel(466814104)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IPCStream?'");
return MsgValueError;
}
auto maybe__reqContentLength = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__reqContentLength) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& reqContentLength = *maybe__reqContentLength;
// Sentinel = 'reqContentLength'
if ((!(((&(reader__)))->ReadSentinel(927794822)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__reqBodyIncludesHeaders = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__reqBodyIncludesHeaders) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& reqBodyIncludesHeaders = *maybe__reqBodyIncludesHeaders;
// Sentinel = 'reqBodyIncludesHeaders'
if ((!(((&(reader__)))->ReadSentinel(1689127114)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__topLevelOuterContentWindowId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__topLevelOuterContentWindowId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& topLevelOuterContentWindowId = *maybe__topLevelOuterContentWindowId;
// Sentinel = 'topLevelOuterContentWindowId'
if ((!(((&(reader__)))->ReadSentinel(2779974491)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__httpTrafficCategory = IPC::ReadParam<uint8_t>((&(reader__)));
if (!maybe__httpTrafficCategory) {
FatalError("Error deserializing 'uint8_t'");
return MsgValueError;
}
auto& httpTrafficCategory = *maybe__httpTrafficCategory;
// Sentinel = 'httpTrafficCategory'
if ((!(((&(reader__)))->ReadSentinel(1295058878)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t'");
return MsgValueError;
}
auto maybe__requestContextID = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__requestContextID) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& requestContextID = *maybe__requestContextID;
// Sentinel = 'requestContextID'
if ((!(((&(reader__)))->ReadSentinel(956761724)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto maybe__classOfService = IPC::ReadParam<ClassOfService>((&(reader__)));
if (!maybe__classOfService) {
FatalError("Error deserializing 'ClassOfService'");
return MsgValueError;
}
auto& classOfService = *maybe__classOfService;
// Sentinel = 'classOfService'
if ((!(((&(reader__)))->ReadSentinel(704710045)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ClassOfService'");
return MsgValueError;
}
auto maybe__initialRwin = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__initialRwin) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& initialRwin = *maybe__initialRwin;
// Sentinel = 'initialRwin'
if ((!(((&(reader__)))->ReadSentinel(458818699)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto maybe__responseTimeoutEnabled = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__responseTimeoutEnabled) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& responseTimeoutEnabled = *maybe__responseTimeoutEnabled;
// Sentinel = 'responseTimeoutEnabled'
if ((!(((&(reader__)))->ReadSentinel(1769408770)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
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__hasTransactionObserver = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__hasTransactionObserver) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& hasTransactionObserver = *maybe__hasTransactionObserver;
// Sentinel = 'hasTransactionObserver'
if ((!(((&(reader__)))->ReadSentinel(1727531275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__pushedStreamArg = IPC::ReadParam<mozilla::Maybe<H2PushedStreamArg>>((&(reader__)));
if (!maybe__pushedStreamArg) {
FatalError("Error deserializing 'H2PushedStreamArg?'");
return MsgValueError;
}
auto& pushedStreamArg = *maybe__pushedStreamArg;
// Sentinel = 'pushedStreamArg'
if ((!(((&(reader__)))->ReadSentinel(833160720)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'H2PushedStreamArg?'");
return MsgValueError;
}
auto maybe__throttleQueue = IPC::ReadParam<mozilla::Maybe<mozilla::NotNull<PInputChannelThrottleQueueChild*>>>((&(reader__)));
if (!maybe__throttleQueue) {
FatalError("Error deserializing 'NotNull<PInputChannelThrottleQueue>?'");
return MsgValueError;
}
auto& throttleQueue = *maybe__throttleQueue;
// Sentinel = 'throttleQueue'
if ((!(((&(reader__)))->ReadSentinel(653919612)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<PInputChannelThrottleQueue>?'");
return MsgValueError;
}
auto maybe__aIsDocumentLoad = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__aIsDocumentLoad) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& aIsDocumentLoad = *maybe__aIsDocumentLoad;
// Sentinel = 'aIsDocumentLoad'
if ((!(((&(reader__)))->ReadSentinel(774440413)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
auto maybe__aRedirectStart = IPC::ReadParam<TimeStamp>((&(reader__)));
if (!maybe__aRedirectStart) {
FatalError("Error deserializing 'TimeStamp'");
return MsgValueError;
}
auto& aRedirectStart = *maybe__aRedirectStart;
// Sentinel = 'aRedirectStart'
if ((!(((&(reader__)))->ReadSentinel(690554274)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TimeStamp'");
return MsgValueError;
}
auto maybe__aRedirectEnd = IPC::ReadParam<TimeStamp>((&(reader__)));
if (!maybe__aRedirectEnd) {
FatalError("Error deserializing 'TimeStamp'");
return MsgValueError;
}
auto& aRedirectEnd = *maybe__aRedirectEnd;
// Sentinel = 'aRedirectEnd'
if ((!(((&(reader__)))->ReadSentinel(505808043)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TimeStamp'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<HttpTransactionChild*>(this))->RecvInit(std::move(caps), std::move(aArgs), std::move(reqHeaders), std::move(requestBody), std::move(reqContentLength), std::move(reqBodyIncludesHeaders), std::move(topLevelOuterContentWindowId), std::move(httpTrafficCategory), std::move(requestContextID), std::move(classOfService), std::move(initialRwin), std::move(responseTimeoutEnabled), std::move(channelId), std::move(hasTransactionObserver), std::move(pushedStreamArg), std::move(throttleQueue), std::move(aIsDocumentLoad), std::move(aRedirectStart), std::move(aRedirectEnd));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PHttpTransaction::Msg_CancelPump__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg_CancelPump", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__status = IPC::ReadParam<nsresult>((&(reader__)));
if (!maybe__status) {
FatalError("Error deserializing 'nsresult'");
return MsgValueError;
}
auto& status = *maybe__status;
// Sentinel = 'status'
if ((!(((&(reader__)))->ReadSentinel(154731173)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<HttpTransactionChild*>(this))->RecvCancelPump(std::move(status));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PHttpTransaction::Msg_SuspendPump__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg_SuspendPump", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<HttpTransactionChild*>(this))->RecvSuspendPump();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PHttpTransaction::Msg_ResumePump__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg_ResumePump", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<HttpTransactionChild*>(this))->RecvResumePump();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PHttpTransaction::Msg_SetDNSWasRefreshed__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg_SetDNSWasRefreshed", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<HttpTransactionChild*>(this))->RecvSetDNSWasRefreshed();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PHttpTransaction::Msg_DontReuseConnection__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg_DontReuseConnection", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<HttpTransactionChild*>(this))->RecvDontReuseConnection();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PHttpTransaction::Msg_SetH2WSConnRefTaken__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PHttpTransactionChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PHttpTransaction::Msg_SetH2WSConnRefTaken", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<HttpTransactionChild*>(this))->RecvSetH2WSConnRefTaken();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
default:
return MsgNotKnown;
}
}
auto PHttpTransactionChild::OnMessageReceived(
const Message& msg__,
UniquePtr<Message>& reply__) -> PHttpTransactionChild::Result
{
return MsgNotKnown;
}
auto PHttpTransactionChild::DoomSubtree() -> void
{
SetDoomed();
}
auto PHttpTransactionChild::PeekManagedActor() -> IProtocol*
{
return nullptr;
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::PHttpTransactionChild*>::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::net::PHttpTransactionChild*>::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, "PHttpTransaction", PHttpTransactionMsgStart);
if (actor.isSome()) {
return static_cast<::mozilla::net::PHttpTransactionChild*>(actor.ref());
}
return {};
}
} // namespace IPC