Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef HttpChannelParams_h
#define HttpChannelParams_h
#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"
// Headers for typedefs
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/net/DNS.h"
#include "nsILoadInfo.h"
#include "nsIReferrerInfo.h"
#include "nsIRequest.h"
#include "nsITRRSkipReason.h"
#include "nsITransportSecurityInfo.h"
#include "mozilla/dom/IPCServiceWorkerDescriptor.h"
#include "mozilla/net/NeckoChannelParams.h"
#include "mozilla/ipc/IPCStream.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct HttpChannelOnStartRequestArgs|
//
namespace mozilla {
namespace net {
class HttpChannelOnStartRequestArgs final
{
private:
typedef ::nsITransportSecurityInfo nsITransportSecurityInfo;
typedef ::nsIReferrerInfo nsIReferrerInfo;
typedef ::uint64_t uint64_t;
typedef ::int64_t int64_t;
typedef ::nsCString nsCString;
typedef ::mozilla::net::NetAddr NetAddr;
typedef ::mozilla::net::ResourceTimingStructArgs ResourceTimingStructArgs;
typedef ::mozilla::net::ParentLoadInfoForwarderArgs ParentLoadInfoForwarderArgs;
typedef ::nsresult nsresult;
typedef ::nsIRequest::TRRMode TRRMode;
typedef ::mozilla::net::TRRSkippedReason TRRSkippedReason;
typedef ::uint32_t uint32_t;
typedef ::nsILoadInfo::CrossOriginOpenerPolicy CrossOriginOpenerPolicy;
typedef ::uint8_t uint8_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
HttpChannelOnStartRequestArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT HttpChannelOnStartRequestArgs(
nsITransportSecurityInfo* _securityInfo,
nsIReferrerInfo* _overrideReferrerInfo,
const uint64_t& _cacheEntryId,
const int64_t& _altDataLength,
const nsCString& _altDataType,
const nsCString& _cookie,
const NetAddr& _selfAddr,
const NetAddr& _peerAddr,
const ResourceTimingStructArgs& _timing,
const ParentLoadInfoForwarderArgs& _loadInfoForwarder,
const nsresult& _channelStatus,
const TRRMode& _effectiveTRRMode,
const TRRSkippedReason& _trrSkipReason,
const uint32_t& _cacheFetchCount,
const uint32_t& _cacheExpirationTime,
const uint32_t& _cacheKey,
const mozilla::Maybe<uint32_t>& _multiPartID,
const bool& _isFromCache,
const bool& _isRacing,
const bool& _cacheEntryAvailable,
const bool& _deliveringAltData,
const bool& _applyConversion,
const bool& _isResolvedByTRR,
const bool& _allRedirectsSameOrigin,
const bool& _isFirstPartOfMultiPart,
const bool& _isLastPartOfMultiPart,
const CrossOriginOpenerPolicy& _openerPolicy,
const bool& _shouldWaitForOnStartRequestSent,
const bool& _dataFromSocketProcess,
const bool& _hasHTTPSRR,
const bool& _isProxyUsed,
const uint8_t& _redirectCount,
const nsCString& _protocolVersion) :
securityInfo_(_securityInfo),
overrideReferrerInfo_(_overrideReferrerInfo),
altDataType_(_altDataType),
cookie_(_cookie),
selfAddr_(_selfAddr),
peerAddr_(_peerAddr),
timing_(_timing),
loadInfoForwarder_(_loadInfoForwarder),
channelStatus_(_channelStatus),
effectiveTRRMode_(_effectiveTRRMode),
trrSkipReason_(_trrSkipReason),
multiPartID_(_multiPartID),
isFromCache_(_isFromCache),
isRacing_(_isRacing),
cacheEntryAvailable_(_cacheEntryAvailable),
deliveringAltData_(_deliveringAltData),
applyConversion_(_applyConversion),
isResolvedByTRR_(_isResolvedByTRR),
allRedirectsSameOrigin_(_allRedirectsSameOrigin),
isFirstPartOfMultiPart_(_isFirstPartOfMultiPart),
isLastPartOfMultiPart_(_isLastPartOfMultiPart),
openerPolicy_(_openerPolicy),
shouldWaitForOnStartRequestSent_(_shouldWaitForOnStartRequestSent),
dataFromSocketProcess_(_dataFromSocketProcess),
hasHTTPSRR_(_hasHTTPSRR),
isProxyUsed_(_isProxyUsed),
protocolVersion_(_protocolVersion),
cacheEntryId_(_cacheEntryId),
altDataLength_(_altDataLength),
cacheFetchCount_(_cacheFetchCount),
cacheExpirationTime_(_cacheExpirationTime),
cacheKey_(_cacheKey),
redirectCount_(_redirectCount)
{
}
MOZ_IMPLICIT HttpChannelOnStartRequestArgs(
RefPtr<nsITransportSecurityInfo>&& _securityInfo,
RefPtr<nsIReferrerInfo>&& _overrideReferrerInfo,
uint64_t&& _cacheEntryId,
int64_t&& _altDataLength,
nsCString&& _altDataType,
nsCString&& _cookie,
NetAddr&& _selfAddr,
NetAddr&& _peerAddr,
ResourceTimingStructArgs&& _timing,
ParentLoadInfoForwarderArgs&& _loadInfoForwarder,
nsresult&& _channelStatus,
TRRMode&& _effectiveTRRMode,
TRRSkippedReason&& _trrSkipReason,
uint32_t&& _cacheFetchCount,
uint32_t&& _cacheExpirationTime,
uint32_t&& _cacheKey,
mozilla::Maybe<uint32_t>&& _multiPartID,
bool&& _isFromCache,
bool&& _isRacing,
bool&& _cacheEntryAvailable,
bool&& _deliveringAltData,
bool&& _applyConversion,
bool&& _isResolvedByTRR,
bool&& _allRedirectsSameOrigin,
bool&& _isFirstPartOfMultiPart,
bool&& _isLastPartOfMultiPart,
CrossOriginOpenerPolicy&& _openerPolicy,
bool&& _shouldWaitForOnStartRequestSent,
bool&& _dataFromSocketProcess,
bool&& _hasHTTPSRR,
bool&& _isProxyUsed,
uint8_t&& _redirectCount,
nsCString&& _protocolVersion) :
securityInfo_(std::move(_securityInfo)),
overrideReferrerInfo_(std::move(_overrideReferrerInfo)),
altDataType_(std::move(_altDataType)),
cookie_(std::move(_cookie)),
selfAddr_(std::move(_selfAddr)),
peerAddr_(std::move(_peerAddr)),
timing_(std::move(_timing)),
loadInfoForwarder_(std::move(_loadInfoForwarder)),
channelStatus_(std::move(_channelStatus)),
effectiveTRRMode_(std::move(_effectiveTRRMode)),
trrSkipReason_(std::move(_trrSkipReason)),
multiPartID_(std::move(_multiPartID)),
isFromCache_(std::move(_isFromCache)),
isRacing_(std::move(_isRacing)),
cacheEntryAvailable_(std::move(_cacheEntryAvailable)),
deliveringAltData_(std::move(_deliveringAltData)),
applyConversion_(std::move(_applyConversion)),
isResolvedByTRR_(std::move(_isResolvedByTRR)),
allRedirectsSameOrigin_(std::move(_allRedirectsSameOrigin)),
isFirstPartOfMultiPart_(std::move(_isFirstPartOfMultiPart)),
isLastPartOfMultiPart_(std::move(_isLastPartOfMultiPart)),
openerPolicy_(std::move(_openerPolicy)),
shouldWaitForOnStartRequestSent_(std::move(_shouldWaitForOnStartRequestSent)),
dataFromSocketProcess_(std::move(_dataFromSocketProcess)),
hasHTTPSRR_(std::move(_hasHTTPSRR)),
isProxyUsed_(std::move(_isProxyUsed)),
protocolVersion_(std::move(_protocolVersion)),
cacheEntryId_(std::move(_cacheEntryId)),
altDataLength_(std::move(_altDataLength)),
cacheFetchCount_(std::move(_cacheFetchCount)),
cacheExpirationTime_(std::move(_cacheExpirationTime)),
cacheKey_(std::move(_cacheKey)),
redirectCount_(std::move(_redirectCount))
{
}
RefPtr<nsITransportSecurityInfo>&
securityInfo()
{
return securityInfo_;
}
nsITransportSecurityInfo*
securityInfo() const
{
return securityInfo_;
}
RefPtr<nsIReferrerInfo>&
overrideReferrerInfo()
{
return overrideReferrerInfo_;
}
nsIReferrerInfo*
overrideReferrerInfo() const
{
return overrideReferrerInfo_;
}
uint64_t&
cacheEntryId()
{
return cacheEntryId_;
}
const uint64_t&
cacheEntryId() const
{
return cacheEntryId_;
}
int64_t&
altDataLength()
{
return altDataLength_;
}
const int64_t&
altDataLength() const
{
return altDataLength_;
}
nsCString&
altDataType()
{
return altDataType_;
}
const nsCString&
altDataType() const
{
return altDataType_;
}
nsCString&
cookie()
{
return cookie_;
}
const nsCString&
cookie() const
{
return cookie_;
}
NetAddr&
selfAddr()
{
return selfAddr_;
}
const NetAddr&
selfAddr() const
{
return selfAddr_;
}
NetAddr&
peerAddr()
{
return peerAddr_;
}
const NetAddr&
peerAddr() const
{
return peerAddr_;
}
ResourceTimingStructArgs&
timing()
{
return timing_;
}
const ResourceTimingStructArgs&
timing() const
{
return timing_;
}
ParentLoadInfoForwarderArgs&
loadInfoForwarder()
{
return loadInfoForwarder_;
}
const ParentLoadInfoForwarderArgs&
loadInfoForwarder() const
{
return loadInfoForwarder_;
}
nsresult&
channelStatus()
{
return channelStatus_;
}
const nsresult&
channelStatus() const
{
return channelStatus_;
}
TRRMode&
effectiveTRRMode()
{
return effectiveTRRMode_;
}
const TRRMode&
effectiveTRRMode() const
{
return effectiveTRRMode_;
}
TRRSkippedReason&
trrSkipReason()
{
return trrSkipReason_;
}
const TRRSkippedReason&
trrSkipReason() const
{
return trrSkipReason_;
}
uint32_t&
cacheFetchCount()
{
return cacheFetchCount_;
}
const uint32_t&
cacheFetchCount() const
{
return cacheFetchCount_;
}
uint32_t&
cacheExpirationTime()
{
return cacheExpirationTime_;
}
const uint32_t&
cacheExpirationTime() const
{
return cacheExpirationTime_;
}
uint32_t&
cacheKey()
{
return cacheKey_;
}
const uint32_t&
cacheKey() const
{
return cacheKey_;
}
mozilla::Maybe<uint32_t>&
multiPartID()
{
return multiPartID_;
}
const mozilla::Maybe<uint32_t>&
multiPartID() const
{
return multiPartID_;
}
bool&
isFromCache()
{
return isFromCache_;
}
const bool&
isFromCache() const
{
return isFromCache_;
}
bool&
isRacing()
{
return isRacing_;
}
const bool&
isRacing() const
{
return isRacing_;
}
bool&
cacheEntryAvailable()
{
return cacheEntryAvailable_;
}
const bool&
cacheEntryAvailable() const
{
return cacheEntryAvailable_;
}
bool&
deliveringAltData()
{
return deliveringAltData_;
}
const bool&
deliveringAltData() const
{
return deliveringAltData_;
}
bool&
applyConversion()
{
return applyConversion_;
}
const bool&
applyConversion() const
{
return applyConversion_;
}
bool&
isResolvedByTRR()
{
return isResolvedByTRR_;
}
const bool&
isResolvedByTRR() const
{
return isResolvedByTRR_;
}
bool&
allRedirectsSameOrigin()
{
return allRedirectsSameOrigin_;
}
const bool&
allRedirectsSameOrigin() const
{
return allRedirectsSameOrigin_;
}
bool&
isFirstPartOfMultiPart()
{
return isFirstPartOfMultiPart_;
}
const bool&
isFirstPartOfMultiPart() const
{
return isFirstPartOfMultiPart_;
}
bool&
isLastPartOfMultiPart()
{
return isLastPartOfMultiPart_;
}
const bool&
isLastPartOfMultiPart() const
{
return isLastPartOfMultiPart_;
}
CrossOriginOpenerPolicy&
openerPolicy()
{
return openerPolicy_;
}
const CrossOriginOpenerPolicy&
openerPolicy() const
{
return openerPolicy_;
}
bool&
shouldWaitForOnStartRequestSent()
{
return shouldWaitForOnStartRequestSent_;
}
const bool&
shouldWaitForOnStartRequestSent() const
{
return shouldWaitForOnStartRequestSent_;
}
bool&
dataFromSocketProcess()
{
return dataFromSocketProcess_;
}
const bool&
dataFromSocketProcess() const
{
return dataFromSocketProcess_;
}
bool&
hasHTTPSRR()
{
return hasHTTPSRR_;
}
const bool&
hasHTTPSRR() const
{
return hasHTTPSRR_;
}
bool&
isProxyUsed()
{
return isProxyUsed_;
}
const bool&
isProxyUsed() const
{
return isProxyUsed_;
}
uint8_t&
redirectCount()
{
return redirectCount_;
}
const uint8_t&
redirectCount() const
{
return redirectCount_;
}
nsCString&
protocolVersion()
{
return protocolVersion_;
}
const nsCString&
protocolVersion() const
{
return protocolVersion_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<RefPtr<nsITransportSecurityInfo>> securityInfo_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIReferrerInfo>> overrideReferrerInfo_;
::mozilla::ipc::IPDLStructMember<nsCString> altDataType_;
::mozilla::ipc::IPDLStructMember<nsCString> cookie_;
::mozilla::ipc::IPDLStructMember<NetAddr> selfAddr_;
::mozilla::ipc::IPDLStructMember<NetAddr> peerAddr_;
::mozilla::ipc::IPDLStructMember<ResourceTimingStructArgs> timing_;
::mozilla::ipc::IPDLStructMember<ParentLoadInfoForwarderArgs> loadInfoForwarder_;
::mozilla::ipc::IPDLStructMember<nsresult> channelStatus_;
::mozilla::ipc::IPDLStructMember<TRRMode> effectiveTRRMode_;
::mozilla::ipc::IPDLStructMember<TRRSkippedReason> trrSkipReason_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<uint32_t>> multiPartID_;
::mozilla::ipc::IPDLStructMember<bool> isFromCache_;
::mozilla::ipc::IPDLStructMember<bool> isRacing_;
::mozilla::ipc::IPDLStructMember<bool> cacheEntryAvailable_;
::mozilla::ipc::IPDLStructMember<bool> deliveringAltData_;
::mozilla::ipc::IPDLStructMember<bool> applyConversion_;
::mozilla::ipc::IPDLStructMember<bool> isResolvedByTRR_;
::mozilla::ipc::IPDLStructMember<bool> allRedirectsSameOrigin_;
::mozilla::ipc::IPDLStructMember<bool> isFirstPartOfMultiPart_;
::mozilla::ipc::IPDLStructMember<bool> isLastPartOfMultiPart_;
::mozilla::ipc::IPDLStructMember<CrossOriginOpenerPolicy> openerPolicy_;
::mozilla::ipc::IPDLStructMember<bool> shouldWaitForOnStartRequestSent_;
::mozilla::ipc::IPDLStructMember<bool> dataFromSocketProcess_;
::mozilla::ipc::IPDLStructMember<bool> hasHTTPSRR_;
::mozilla::ipc::IPDLStructMember<bool> isProxyUsed_;
::mozilla::ipc::IPDLStructMember<nsCString> protocolVersion_;
::mozilla::ipc::IPDLStructMember<uint64_t> cacheEntryId_;
::mozilla::ipc::IPDLStructMember<int64_t> altDataLength_;
::mozilla::ipc::IPDLStructMember<uint32_t> cacheFetchCount_;
::mozilla::ipc::IPDLStructMember<uint32_t> cacheExpirationTime_;
::mozilla::ipc::IPDLStructMember<uint32_t> cacheKey_;
::mozilla::ipc::IPDLStructMember<uint8_t> redirectCount_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpChannelOnStartRequestArgs>
{
typedef ::mozilla::net::HttpChannelOnStartRequestArgs paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct HttpChannelAltDataStream|
//
namespace mozilla {
namespace net {
class HttpChannelAltDataStream final
{
private:
typedef ::mozilla::ipc::IPCStream IPCStream;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
HttpChannelAltDataStream() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT HttpChannelAltDataStream(const mozilla::Maybe<IPCStream>& _altDataInputStream) :
altDataInputStream_(_altDataInputStream)
{
}
MOZ_IMPLICIT HttpChannelAltDataStream(mozilla::Maybe<IPCStream>&& _altDataInputStream) :
altDataInputStream_(std::move(_altDataInputStream))
{
}
mozilla::Maybe<IPCStream>&
altDataInputStream()
{
return altDataInputStream_;
}
const mozilla::Maybe<IPCStream>&
altDataInputStream() const
{
return altDataInputStream_;
}
private:
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCStream>> altDataInputStream_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpChannelAltDataStream>
{
typedef ::mozilla::net::HttpChannelAltDataStream paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
#endif // ifndef HttpChannelParams_h