mozilla-central/__GENERATED__/ipc/ipdl/_ipdlheaders/mozilla/net/NeckoChannelParams.h (file symbol)

Copy as Markdown

Other Tools

//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef NeckoChannelParams_h
#define NeckoChannelParams_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/TimeStamp.h"
#include "mozilla/dom/FeaturePolicy.h"
#include "mozilla/dom/RequestBinding.h"
#include "mozilla/dom/SessionHistoryEntry.h"
#include "mozilla/ipc/BackgroundUtils.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/net/PHttpChannelParams.h"
#include "nsDOMNavigationTiming.h"
#include "nsDocShellLoadState.h"
#include "nsICacheInfoChannel.h"
#include "nsIContentPolicy.h"
#include "nsILoadInfo.h"
#include "nsIPropertyBag2.h"
#include "nsNetUtil.h"
#include "mozilla/dom/ClientIPCTypes.h"
#include "mozilla/ipc/URIParams.h"
#include "mozilla/dom/IPCServiceWorkerDescriptor.h"
#include "mozilla/ipc/IPCStream.h"
#include "mozilla/ipc/PBackgroundSharedTypes.h"
#include "mozilla/dom/DOMTypes.h"
#include "mozilla/ipc/ProtocolTypes.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct CookiePermissionData|
//
namespace mozilla {
namespace net {
class CookiePermissionData final
{
private:
typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
typedef ::uint32_t uint32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
CookiePermissionData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CookiePermissionData(
const PrincipalInfo& _principalInfo,
const uint32_t& _cookiePermission) :
principalInfo_(_principalInfo),
cookiePermission_(_cookiePermission)
{
}
MOZ_IMPLICIT CookiePermissionData(
PrincipalInfo&& _principalInfo,
uint32_t&& _cookiePermission) :
principalInfo_(std::move(_principalInfo)),
cookiePermission_(std::move(_cookiePermission))
{
}
PrincipalInfo&
principalInfo()
{
return principalInfo_;
}
const PrincipalInfo&
principalInfo() const
{
return principalInfo_;
}
uint32_t&
cookiePermission()
{
return cookiePermission_;
}
const uint32_t&
cookiePermission() const
{
return cookiePermission_;
}
private:
::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
::mozilla::ipc::IPDLStructMember<uint32_t> cookiePermission_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::CookiePermissionData>
{
typedef ::mozilla::net::CookiePermissionData 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 CookieJarSettingsArgs|
//
namespace mozilla {
namespace net {
class CookieJarSettingsArgs final
{
private:
typedef ::uint32_t uint32_t;
typedef ::mozilla::net::CookiePermissionData CookiePermissionData;
typedef ::nsString nsString;
typedef ::uint8_t uint8_t;
typedef ::uint64_t uint64_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
CookieJarSettingsArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CookieJarSettingsArgs(
const uint32_t& _cookieBehavior,
const bool& _isFirstPartyIsolated,
const bool& _shouldResistFingerprinting,
const bool& _isOnContentBlockingAllowList,
const nsTArray<CookiePermissionData>& _cookiePermissions,
const bool& _isFixed,
const nsString& _partitionKey,
const bool& _hasFingerprintingRandomizationKey,
const nsTArray<uint8_t>& _fingerprintingRandomizationKey,
const uint64_t& _topLevelWindowContextId) :
isFirstPartyIsolated_(_isFirstPartyIsolated),
shouldResistFingerprinting_(_shouldResistFingerprinting),
isOnContentBlockingAllowList_(_isOnContentBlockingAllowList),
cookiePermissions_(_cookiePermissions),
isFixed_(_isFixed),
partitionKey_(_partitionKey),
hasFingerprintingRandomizationKey_(_hasFingerprintingRandomizationKey),
fingerprintingRandomizationKey_(_fingerprintingRandomizationKey),
topLevelWindowContextId_(_topLevelWindowContextId),
cookieBehavior_(_cookieBehavior)
{
}
MOZ_IMPLICIT CookieJarSettingsArgs(
uint32_t&& _cookieBehavior,
bool&& _isFirstPartyIsolated,
bool&& _shouldResistFingerprinting,
bool&& _isOnContentBlockingAllowList,
nsTArray<CookiePermissionData>&& _cookiePermissions,
bool&& _isFixed,
nsString&& _partitionKey,
bool&& _hasFingerprintingRandomizationKey,
nsTArray<uint8_t>&& _fingerprintingRandomizationKey,
uint64_t&& _topLevelWindowContextId) :
isFirstPartyIsolated_(std::move(_isFirstPartyIsolated)),
shouldResistFingerprinting_(std::move(_shouldResistFingerprinting)),
isOnContentBlockingAllowList_(std::move(_isOnContentBlockingAllowList)),
cookiePermissions_(std::move(_cookiePermissions)),
isFixed_(std::move(_isFixed)),
partitionKey_(std::move(_partitionKey)),
hasFingerprintingRandomizationKey_(std::move(_hasFingerprintingRandomizationKey)),
fingerprintingRandomizationKey_(std::move(_fingerprintingRandomizationKey)),
topLevelWindowContextId_(std::move(_topLevelWindowContextId)),
cookieBehavior_(std::move(_cookieBehavior))
{
}
uint32_t&
cookieBehavior()
{
return cookieBehavior_;
}
const uint32_t&
cookieBehavior() const
{
return cookieBehavior_;
}
bool&
isFirstPartyIsolated()
{
return isFirstPartyIsolated_;
}
const bool&
isFirstPartyIsolated() const
{
return isFirstPartyIsolated_;
}
bool&
shouldResistFingerprinting()
{
return shouldResistFingerprinting_;
}
const bool&
shouldResistFingerprinting() const
{
return shouldResistFingerprinting_;
}
bool&
isOnContentBlockingAllowList()
{
return isOnContentBlockingAllowList_;
}
const bool&
isOnContentBlockingAllowList() const
{
return isOnContentBlockingAllowList_;
}
nsTArray<CookiePermissionData>&
cookiePermissions()
{
return cookiePermissions_;
}
const nsTArray<CookiePermissionData>&
cookiePermissions() const
{
return cookiePermissions_;
}
bool&
isFixed()
{
return isFixed_;
}
const bool&
isFixed() const
{
return isFixed_;
}
nsString&
partitionKey()
{
return partitionKey_;
}
const nsString&
partitionKey() const
{
return partitionKey_;
}
bool&
hasFingerprintingRandomizationKey()
{
return hasFingerprintingRandomizationKey_;
}
const bool&
hasFingerprintingRandomizationKey() const
{
return hasFingerprintingRandomizationKey_;
}
nsTArray<uint8_t>&
fingerprintingRandomizationKey()
{
return fingerprintingRandomizationKey_;
}
const nsTArray<uint8_t>&
fingerprintingRandomizationKey() const
{
return fingerprintingRandomizationKey_;
}
uint64_t&
topLevelWindowContextId()
{
return topLevelWindowContextId_;
}
const uint64_t&
topLevelWindowContextId() const
{
return topLevelWindowContextId_;
}
private:
::mozilla::ipc::IPDLStructMember<bool> isFirstPartyIsolated_;
::mozilla::ipc::IPDLStructMember<bool> shouldResistFingerprinting_;
::mozilla::ipc::IPDLStructMember<bool> isOnContentBlockingAllowList_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<CookiePermissionData>> cookiePermissions_;
::mozilla::ipc::IPDLStructMember<bool> isFixed_;
::mozilla::ipc::IPDLStructMember<nsString> partitionKey_;
::mozilla::ipc::IPDLStructMember<bool> hasFingerprintingRandomizationKey_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> fingerprintingRandomizationKey_;
::mozilla::ipc::IPDLStructMember<uint64_t> topLevelWindowContextId_;
::mozilla::ipc::IPDLStructMember<uint32_t> cookieBehavior_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::CookieJarSettingsArgs>
{
typedef ::mozilla::net::CookieJarSettingsArgs 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 PreferredAlternativeDataTypeParams|
//
namespace mozilla {
namespace net {
class PreferredAlternativeDataTypeParams final
{
private:
typedef ::nsCString nsCString;
typedef ::mozilla::net::PreferredAlternativeDataDeliveryTypeIPC PreferredAlternativeDataDeliveryTypeIPC;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
PreferredAlternativeDataTypeParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT PreferredAlternativeDataTypeParams(
const nsCString& _type,
const nsCString& _contentType,
const PreferredAlternativeDataDeliveryTypeIPC& _deliverAltData) :
type_(_type),
contentType_(_contentType),
deliverAltData_(_deliverAltData)
{
}
MOZ_IMPLICIT PreferredAlternativeDataTypeParams(
nsCString&& _type,
nsCString&& _contentType,
PreferredAlternativeDataDeliveryTypeIPC&& _deliverAltData) :
type_(std::move(_type)),
contentType_(std::move(_contentType)),
deliverAltData_(std::move(_deliverAltData))
{
}
nsCString&
type()
{
return type_;
}
const nsCString&
type() const
{
return type_;
}
nsCString&
contentType()
{
return contentType_;
}
const nsCString&
contentType() const
{
return contentType_;
}
PreferredAlternativeDataDeliveryTypeIPC&
deliverAltData()
{
return deliverAltData_;
}
const PreferredAlternativeDataDeliveryTypeIPC&
deliverAltData() const
{
return deliverAltData_;
}
private:
::mozilla::ipc::IPDLStructMember<nsCString> type_;
::mozilla::ipc::IPDLStructMember<nsCString> contentType_;
::mozilla::ipc::IPDLStructMember<PreferredAlternativeDataDeliveryTypeIPC> deliverAltData_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::PreferredAlternativeDataTypeParams>
{
typedef ::mozilla::net::PreferredAlternativeDataTypeParams 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 RedirectHistoryEntryInfo|
//
namespace mozilla {
namespace net {
class RedirectHistoryEntryInfo final
{
private:
typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
typedef ::mozilla::ipc::URIParams URIParams;
typedef ::nsCString nsCString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
RedirectHistoryEntryInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT RedirectHistoryEntryInfo(
const PrincipalInfo& _principalInfo,
const mozilla::Maybe<URIParams>& _referrerUri,
const nsCString& _remoteAddress) :
principalInfo_(_principalInfo),
referrerUri_(_referrerUri),
remoteAddress_(_remoteAddress)
{
}
MOZ_IMPLICIT RedirectHistoryEntryInfo(
PrincipalInfo&& _principalInfo,
mozilla::Maybe<URIParams>&& _referrerUri,
nsCString&& _remoteAddress) :
principalInfo_(std::move(_principalInfo)),
referrerUri_(std::move(_referrerUri)),
remoteAddress_(std::move(_remoteAddress))
{
}
PrincipalInfo&
principalInfo()
{
return principalInfo_;
}
const PrincipalInfo&
principalInfo() const
{
return principalInfo_;
}
mozilla::Maybe<URIParams>&
referrerUri()
{
return referrerUri_;
}
const mozilla::Maybe<URIParams>&
referrerUri() const
{
return referrerUri_;
}
nsCString&
remoteAddress()
{
return remoteAddress_;
}
const nsCString&
remoteAddress() const
{
return remoteAddress_;
}
private:
::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<URIParams>> referrerUri_;
::mozilla::ipc::IPDLStructMember<nsCString> remoteAddress_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::RedirectHistoryEntryInfo>
{
typedef ::mozilla::net::RedirectHistoryEntryInfo 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 InterceptionInfoArg|
//
namespace mozilla {
namespace net {
class InterceptionInfoArg final
{
private:
typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
typedef ::nsContentPolicyType nsContentPolicyType;
typedef ::mozilla::net::RedirectHistoryEntryInfo RedirectHistoryEntryInfo;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
InterceptionInfoArg() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT InterceptionInfoArg(
const mozilla::Maybe<PrincipalInfo>& _triggeringPrincipalInfo,
const nsContentPolicyType& _contentPolicyType,
const nsTArray<RedirectHistoryEntryInfo>& _redirectChain,
const bool& _fromThirdParty) :
triggeringPrincipalInfo_(_triggeringPrincipalInfo),
contentPolicyType_(_contentPolicyType),
redirectChain_(_redirectChain),
fromThirdParty_(_fromThirdParty)
{
}
MOZ_IMPLICIT InterceptionInfoArg(
mozilla::Maybe<PrincipalInfo>&& _triggeringPrincipalInfo,
nsContentPolicyType&& _contentPolicyType,
nsTArray<RedirectHistoryEntryInfo>&& _redirectChain,
bool&& _fromThirdParty) :
triggeringPrincipalInfo_(std::move(_triggeringPrincipalInfo)),
contentPolicyType_(std::move(_contentPolicyType)),
redirectChain_(std::move(_redirectChain)),
fromThirdParty_(std::move(_fromThirdParty))
{
}
mozilla::Maybe<PrincipalInfo>&
triggeringPrincipalInfo()
{
return triggeringPrincipalInfo_;
}
const mozilla::Maybe<PrincipalInfo>&
triggeringPrincipalInfo() const
{
return triggeringPrincipalInfo_;
}
nsContentPolicyType&
contentPolicyType()
{
return contentPolicyType_;
}
const nsContentPolicyType&
contentPolicyType() const
{
return contentPolicyType_;
}
nsTArray<RedirectHistoryEntryInfo>&
redirectChain()
{
return redirectChain_;
}
const nsTArray<RedirectHistoryEntryInfo>&
redirectChain() const
{
return redirectChain_;
}
bool&
fromThirdParty()
{
return fromThirdParty_;
}
const bool&
fromThirdParty() const
{
return fromThirdParty_;
}
private:
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> triggeringPrincipalInfo_;
::mozilla::ipc::IPDLStructMember<nsContentPolicyType> contentPolicyType_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<RedirectHistoryEntryInfo>> redirectChain_;
::mozilla::ipc::IPDLStructMember<bool> fromThirdParty_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::InterceptionInfoArg>
{
typedef ::mozilla::net::InterceptionInfoArg 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 LoadInfoArgs|
//
namespace mozilla {
namespace net {
class LoadInfoArgs final
{
private:
typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
typedef ::mozilla::ipc::URIParams URIParams;
typedef ::nsCString nsCString;
typedef ::nsID nsID;
typedef ::uint32_t uint32_t;
typedef ::uint64_t uint64_t;
typedef ::nsContentPolicyType nsContentPolicyType;
typedef ::mozilla::OriginAttributes OriginAttributes;
typedef ::mozilla::net::RedirectHistoryEntryInfo RedirectHistoryEntryInfo;
typedef ::nsILoadInfo::SchemelessInputType SchemelessInputType;
typedef ::nsILoadInfo::HTTPSUpgradeTelemetryType HTTPSUpgradeTelemetryType;
typedef ::mozilla::dom::IPCClientInfo IPCClientInfo;
typedef ::mozilla::dom::IPCServiceWorkerDescriptor IPCServiceWorkerDescriptor;
typedef ::nsString nsString;
typedef ::mozilla::net::CookieJarSettingsArgs CookieJarSettingsArgs;
typedef ::mozilla::ipc::CSPInfo CSPInfo;
typedef ::nsILoadInfo::StoragePermissionState StoragePermissionState;
typedef ::nsILoadInfo::CrossOriginEmbedderPolicy CrossOriginEmbedderPolicy;
typedef ::nsIURI nsIURI;
typedef ::mozilla::net::InterceptionInfoArg InterceptionInfoArg;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
LoadInfoArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT LoadInfoArgs(
const mozilla::Maybe<PrincipalInfo>& _requestingPrincipalInfo,
const PrincipalInfo& _triggeringPrincipalInfo,
const mozilla::Maybe<PrincipalInfo>& _principalToInheritInfo,
const mozilla::Maybe<PrincipalInfo>& _topLevelPrincipalInfo,
const mozilla::Maybe<URIParams>& _resultPrincipalURI,
const nsCString& _triggeringRemoteType,
const nsID& _sandboxedNullPrincipalID,
const uint32_t& _securityFlags,
const uint32_t& _sandboxFlags,
const uint32_t& _triggeringSandboxFlags,
const uint64_t& _triggeringWindowId,
const bool& _triggeringStorageAccess,
const nsContentPolicyType& _contentPolicyType,
const uint32_t& _tainting,
const bool& _blockAllMixedContent,
const bool& _upgradeInsecureRequests,
const bool& _browserUpgradeInsecureRequests,
const bool& _browserDidUpgradeInsecureRequests,
const bool& _browserWouldUpgradeInsecureRequests,
const bool& _forceAllowDataURI,
const bool& _allowInsecureRedirectToDataURI,
const bool& _skipContentPolicyCheckForWebRequest,
const bool& _originalFrameSrcLoad,
const bool& _forceInheritPrincipalDropped,
const uint64_t& _innerWindowID,
const uint64_t& _browsingContextID,
const uint64_t& _frameBrowsingContextID,
const bool& _initialSecurityCheckDone,
const bool& _isInThirdPartyContext,
const mozilla::Maybe<bool>& _isThirdPartyContextToTopWindow,
const bool& _isFormSubmission,
const bool& _isGETRequest,
const bool& _sendCSPViolationEvents,
const OriginAttributes& _originAttributes,
const nsTArray<RedirectHistoryEntryInfo>& _redirectChainIncludingInternalRedirects,
const nsTArray<RedirectHistoryEntryInfo>& _redirectChain,
const bool& _hasInjectedCookieForCookieBannerHandling,
const SchemelessInputType& _schemelessInput,
const HTTPSUpgradeTelemetryType& _httpsUpgradeTelemetry,
const mozilla::Maybe<IPCClientInfo>& _clientInfo,
const mozilla::Maybe<IPCClientInfo>& _reservedClientInfo,
const mozilla::Maybe<IPCClientInfo>& _initialClientInfo,
const mozilla::Maybe<IPCServiceWorkerDescriptor>& _controller,
const nsTArray<nsCString>& _corsUnsafeHeaders,
const bool& _forcePreflight,
const bool& _isPreflight,
const bool& _loadTriggeredFromExternal,
const bool& _serviceWorkerTaintingSynthesized,
const bool& _documentHasUserInteracted,
const bool& _allowListFutureDocumentsCreatedFromThisRedirectChain,
const bool& _needForCheckingAntiTrackingHeuristic,
const nsString& _cspNonce,
const nsString& _integrityMetadata,
const bool& _skipContentSniffing,
const uint32_t& _httpsOnlyStatus,
const bool& _hstsStatus,
const bool& _hasValidUserGestureActivation,
const bool& _textDirectiveUserActivation,
const bool& _allowDeprecatedSystemRequests,
const bool& _isInDevToolsContext,
const bool& _parserCreatedScript,
const bool& _isFromProcessingFrameAttributes,
const bool& _isMediaRequest,
const bool& _isMediaInitialRequest,
const bool& _isFromObjectOrEmbed,
const CookieJarSettingsArgs& _cookieJarSettings,
const uint32_t& _requestBlockingReason,
const mozilla::Maybe<CSPInfo>& _cspToInheritInfo,
const StoragePermissionState& _storagePermission,
const mozilla::Maybe<uint64_t>& _overriddenFingerprintingSettings,
const bool& _isMetaRefresh,
const CrossOriginEmbedderPolicy& _loadingEmbedderPolicy,
const bool& _originTrialCoepCredentiallessEnabledForTopLevel,
nsIURI* _unstrippedURI,
const mozilla::Maybe<InterceptionInfoArg>& _interceptionInfo,
const bool& _isNewWindowTarget) :
requestingPrincipalInfo_(_requestingPrincipalInfo),
triggeringPrincipalInfo_(_triggeringPrincipalInfo),
principalToInheritInfo_(_principalToInheritInfo),
topLevelPrincipalInfo_(_topLevelPrincipalInfo),
resultPrincipalURI_(_resultPrincipalURI),
triggeringRemoteType_(_triggeringRemoteType),
sandboxedNullPrincipalID_(_sandboxedNullPrincipalID),
triggeringStorageAccess_(_triggeringStorageAccess),
contentPolicyType_(_contentPolicyType),
blockAllMixedContent_(_blockAllMixedContent),
upgradeInsecureRequests_(_upgradeInsecureRequests),
browserUpgradeInsecureRequests_(_browserUpgradeInsecureRequests),
browserDidUpgradeInsecureRequests_(_browserDidUpgradeInsecureRequests),
browserWouldUpgradeInsecureRequests_(_browserWouldUpgradeInsecureRequests),
forceAllowDataURI_(_forceAllowDataURI),
allowInsecureRedirectToDataURI_(_allowInsecureRedirectToDataURI),
skipContentPolicyCheckForWebRequest_(_skipContentPolicyCheckForWebRequest),
originalFrameSrcLoad_(_originalFrameSrcLoad),
forceInheritPrincipalDropped_(_forceInheritPrincipalDropped),
initialSecurityCheckDone_(_initialSecurityCheckDone),
isInThirdPartyContext_(_isInThirdPartyContext),
isThirdPartyContextToTopWindow_(_isThirdPartyContextToTopWindow),
isFormSubmission_(_isFormSubmission),
isGETRequest_(_isGETRequest),
sendCSPViolationEvents_(_sendCSPViolationEvents),
originAttributes_(_originAttributes),
redirectChainIncludingInternalRedirects_(_redirectChainIncludingInternalRedirects),
redirectChain_(_redirectChain),
hasInjectedCookieForCookieBannerHandling_(_hasInjectedCookieForCookieBannerHandling),
schemelessInput_(_schemelessInput),
httpsUpgradeTelemetry_(_httpsUpgradeTelemetry),
clientInfo_(_clientInfo),
reservedClientInfo_(_reservedClientInfo),
initialClientInfo_(_initialClientInfo),
controller_(_controller),
corsUnsafeHeaders_(_corsUnsafeHeaders),
forcePreflight_(_forcePreflight),
isPreflight_(_isPreflight),
loadTriggeredFromExternal_(_loadTriggeredFromExternal),
serviceWorkerTaintingSynthesized_(_serviceWorkerTaintingSynthesized),
documentHasUserInteracted_(_documentHasUserInteracted),
allowListFutureDocumentsCreatedFromThisRedirectChain_(_allowListFutureDocumentsCreatedFromThisRedirectChain),
needForCheckingAntiTrackingHeuristic_(_needForCheckingAntiTrackingHeuristic),
cspNonce_(_cspNonce),
integrityMetadata_(_integrityMetadata),
skipContentSniffing_(_skipContentSniffing),
hstsStatus_(_hstsStatus),
hasValidUserGestureActivation_(_hasValidUserGestureActivation),
textDirectiveUserActivation_(_textDirectiveUserActivation),
allowDeprecatedSystemRequests_(_allowDeprecatedSystemRequests),
isInDevToolsContext_(_isInDevToolsContext),
parserCreatedScript_(_parserCreatedScript),
isFromProcessingFrameAttributes_(_isFromProcessingFrameAttributes),
isMediaRequest_(_isMediaRequest),
isMediaInitialRequest_(_isMediaInitialRequest),
isFromObjectOrEmbed_(_isFromObjectOrEmbed),
cookieJarSettings_(_cookieJarSettings),
cspToInheritInfo_(_cspToInheritInfo),
storagePermission_(_storagePermission),
overriddenFingerprintingSettings_(_overriddenFingerprintingSettings),
isMetaRefresh_(_isMetaRefresh),
loadingEmbedderPolicy_(_loadingEmbedderPolicy),
originTrialCoepCredentiallessEnabledForTopLevel_(_originTrialCoepCredentiallessEnabledForTopLevel),
unstrippedURI_(_unstrippedURI),
interceptionInfo_(_interceptionInfo),
isNewWindowTarget_(_isNewWindowTarget),
triggeringWindowId_(_triggeringWindowId),
innerWindowID_(_innerWindowID),
browsingContextID_(_browsingContextID),
frameBrowsingContextID_(_frameBrowsingContextID),
securityFlags_(_securityFlags),
sandboxFlags_(_sandboxFlags),
triggeringSandboxFlags_(_triggeringSandboxFlags),
tainting_(_tainting),
httpsOnlyStatus_(_httpsOnlyStatus),
requestBlockingReason_(_requestBlockingReason)
{
}
MOZ_IMPLICIT LoadInfoArgs(
mozilla::Maybe<PrincipalInfo>&& _requestingPrincipalInfo,
PrincipalInfo&& _triggeringPrincipalInfo,
mozilla::Maybe<PrincipalInfo>&& _principalToInheritInfo,
mozilla::Maybe<PrincipalInfo>&& _topLevelPrincipalInfo,
mozilla::Maybe<URIParams>&& _resultPrincipalURI,
nsCString&& _triggeringRemoteType,
nsID&& _sandboxedNullPrincipalID,
uint32_t&& _securityFlags,
uint32_t&& _sandboxFlags,
uint32_t&& _triggeringSandboxFlags,
uint64_t&& _triggeringWindowId,
bool&& _triggeringStorageAccess,
nsContentPolicyType&& _contentPolicyType,
uint32_t&& _tainting,
bool&& _blockAllMixedContent,
bool&& _upgradeInsecureRequests,
bool&& _browserUpgradeInsecureRequests,
bool&& _browserDidUpgradeInsecureRequests,
bool&& _browserWouldUpgradeInsecureRequests,
bool&& _forceAllowDataURI,
bool&& _allowInsecureRedirectToDataURI,
bool&& _skipContentPolicyCheckForWebRequest,
bool&& _originalFrameSrcLoad,
bool&& _forceInheritPrincipalDropped,
uint64_t&& _innerWindowID,
uint64_t&& _browsingContextID,
uint64_t&& _frameBrowsingContextID,
bool&& _initialSecurityCheckDone,
bool&& _isInThirdPartyContext,
mozilla::Maybe<bool>&& _isThirdPartyContextToTopWindow,
bool&& _isFormSubmission,
bool&& _isGETRequest,
bool&& _sendCSPViolationEvents,
OriginAttributes&& _originAttributes,
nsTArray<RedirectHistoryEntryInfo>&& _redirectChainIncludingInternalRedirects,
nsTArray<RedirectHistoryEntryInfo>&& _redirectChain,
bool&& _hasInjectedCookieForCookieBannerHandling,
SchemelessInputType&& _schemelessInput,
HTTPSUpgradeTelemetryType&& _httpsUpgradeTelemetry,
mozilla::Maybe<IPCClientInfo>&& _clientInfo,
mozilla::Maybe<IPCClientInfo>&& _reservedClientInfo,
mozilla::Maybe<IPCClientInfo>&& _initialClientInfo,
mozilla::Maybe<IPCServiceWorkerDescriptor>&& _controller,
nsTArray<nsCString>&& _corsUnsafeHeaders,
bool&& _forcePreflight,
bool&& _isPreflight,
bool&& _loadTriggeredFromExternal,
bool&& _serviceWorkerTaintingSynthesized,
bool&& _documentHasUserInteracted,
bool&& _allowListFutureDocumentsCreatedFromThisRedirectChain,
bool&& _needForCheckingAntiTrackingHeuristic,
nsString&& _cspNonce,
nsString&& _integrityMetadata,
bool&& _skipContentSniffing,
uint32_t&& _httpsOnlyStatus,
bool&& _hstsStatus,
bool&& _hasValidUserGestureActivation,
bool&& _textDirectiveUserActivation,
bool&& _allowDeprecatedSystemRequests,
bool&& _isInDevToolsContext,
bool&& _parserCreatedScript,
bool&& _isFromProcessingFrameAttributes,
bool&& _isMediaRequest,
bool&& _isMediaInitialRequest,
bool&& _isFromObjectOrEmbed,
CookieJarSettingsArgs&& _cookieJarSettings,
uint32_t&& _requestBlockingReason,
mozilla::Maybe<CSPInfo>&& _cspToInheritInfo,
StoragePermissionState&& _storagePermission,
mozilla::Maybe<uint64_t>&& _overriddenFingerprintingSettings,
bool&& _isMetaRefresh,
CrossOriginEmbedderPolicy&& _loadingEmbedderPolicy,
bool&& _originTrialCoepCredentiallessEnabledForTopLevel,
RefPtr<nsIURI>&& _unstrippedURI,
mozilla::Maybe<InterceptionInfoArg>&& _interceptionInfo,
bool&& _isNewWindowTarget) :
requestingPrincipalInfo_(std::move(_requestingPrincipalInfo)),
triggeringPrincipalInfo_(std::move(_triggeringPrincipalInfo)),
principalToInheritInfo_(std::move(_principalToInheritInfo)),
topLevelPrincipalInfo_(std::move(_topLevelPrincipalInfo)),
resultPrincipalURI_(std::move(_resultPrincipalURI)),
triggeringRemoteType_(std::move(_triggeringRemoteType)),
sandboxedNullPrincipalID_(std::move(_sandboxedNullPrincipalID)),
triggeringStorageAccess_(std::move(_triggeringStorageAccess)),
contentPolicyType_(std::move(_contentPolicyType)),
blockAllMixedContent_(std::move(_blockAllMixedContent)),
upgradeInsecureRequests_(std::move(_upgradeInsecureRequests)),
browserUpgradeInsecureRequests_(std::move(_browserUpgradeInsecureRequests)),
browserDidUpgradeInsecureRequests_(std::move(_browserDidUpgradeInsecureRequests)),
browserWouldUpgradeInsecureRequests_(std::move(_browserWouldUpgradeInsecureRequests)),
forceAllowDataURI_(std::move(_forceAllowDataURI)),
allowInsecureRedirectToDataURI_(std::move(_allowInsecureRedirectToDataURI)),
skipContentPolicyCheckForWebRequest_(std::move(_skipContentPolicyCheckForWebRequest)),
originalFrameSrcLoad_(std::move(_originalFrameSrcLoad)),
forceInheritPrincipalDropped_(std::move(_forceInheritPrincipalDropped)),
initialSecurityCheckDone_(std::move(_initialSecurityCheckDone)),
isInThirdPartyContext_(std::move(_isInThirdPartyContext)),
isThirdPartyContextToTopWindow_(std::move(_isThirdPartyContextToTopWindow)),
isFormSubmission_(std::move(_isFormSubmission)),
isGETRequest_(std::move(_isGETRequest)),
sendCSPViolationEvents_(std::move(_sendCSPViolationEvents)),
originAttributes_(std::move(_originAttributes)),
redirectChainIncludingInternalRedirects_(std::move(_redirectChainIncludingInternalRedirects)),
redirectChain_(std::move(_redirectChain)),
hasInjectedCookieForCookieBannerHandling_(std::move(_hasInjectedCookieForCookieBannerHandling)),
schemelessInput_(std::move(_schemelessInput)),
httpsUpgradeTelemetry_(std::move(_httpsUpgradeTelemetry)),
clientInfo_(std::move(_clientInfo)),
reservedClientInfo_(std::move(_reservedClientInfo)),
initialClientInfo_(std::move(_initialClientInfo)),
controller_(std::move(_controller)),
corsUnsafeHeaders_(std::move(_corsUnsafeHeaders)),
forcePreflight_(std::move(_forcePreflight)),
isPreflight_(std::move(_isPreflight)),
loadTriggeredFromExternal_(std::move(_loadTriggeredFromExternal)),
serviceWorkerTaintingSynthesized_(std::move(_serviceWorkerTaintingSynthesized)),
documentHasUserInteracted_(std::move(_documentHasUserInteracted)),
allowListFutureDocumentsCreatedFromThisRedirectChain_(std::move(_allowListFutureDocumentsCreatedFromThisRedirectChain)),
needForCheckingAntiTrackingHeuristic_(std::move(_needForCheckingAntiTrackingHeuristic)),
cspNonce_(std::move(_cspNonce)),
integrityMetadata_(std::move(_integrityMetadata)),
skipContentSniffing_(std::move(_skipContentSniffing)),
hstsStatus_(std::move(_hstsStatus)),
hasValidUserGestureActivation_(std::move(_hasValidUserGestureActivation)),
textDirectiveUserActivation_(std::move(_textDirectiveUserActivation)),
allowDeprecatedSystemRequests_(std::move(_allowDeprecatedSystemRequests)),
isInDevToolsContext_(std::move(_isInDevToolsContext)),
parserCreatedScript_(std::move(_parserCreatedScript)),
isFromProcessingFrameAttributes_(std::move(_isFromProcessingFrameAttributes)),
isMediaRequest_(std::move(_isMediaRequest)),
isMediaInitialRequest_(std::move(_isMediaInitialRequest)),
isFromObjectOrEmbed_(std::move(_isFromObjectOrEmbed)),
cookieJarSettings_(std::move(_cookieJarSettings)),
cspToInheritInfo_(std::move(_cspToInheritInfo)),
storagePermission_(std::move(_storagePermission)),
overriddenFingerprintingSettings_(std::move(_overriddenFingerprintingSettings)),
isMetaRefresh_(std::move(_isMetaRefresh)),
loadingEmbedderPolicy_(std::move(_loadingEmbedderPolicy)),
originTrialCoepCredentiallessEnabledForTopLevel_(std::move(_originTrialCoepCredentiallessEnabledForTopLevel)),
unstrippedURI_(std::move(_unstrippedURI)),
interceptionInfo_(std::move(_interceptionInfo)),
isNewWindowTarget_(std::move(_isNewWindowTarget)),
triggeringWindowId_(std::move(_triggeringWindowId)),
innerWindowID_(std::move(_innerWindowID)),
browsingContextID_(std::move(_browsingContextID)),
frameBrowsingContextID_(std::move(_frameBrowsingContextID)),
securityFlags_(std::move(_securityFlags)),
sandboxFlags_(std::move(_sandboxFlags)),
triggeringSandboxFlags_(std::move(_triggeringSandboxFlags)),
tainting_(std::move(_tainting)),
httpsOnlyStatus_(std::move(_httpsOnlyStatus)),
requestBlockingReason_(std::move(_requestBlockingReason))
{
}
mozilla::Maybe<PrincipalInfo>&
requestingPrincipalInfo()
{
return requestingPrincipalInfo_;
}
const mozilla::Maybe<PrincipalInfo>&
requestingPrincipalInfo() const
{
return requestingPrincipalInfo_;
}
PrincipalInfo&
triggeringPrincipalInfo()
{
return triggeringPrincipalInfo_;
}
const PrincipalInfo&
triggeringPrincipalInfo() const
{
return triggeringPrincipalInfo_;
}
mozilla::Maybe<PrincipalInfo>&
principalToInheritInfo()
{
return principalToInheritInfo_;
}
const mozilla::Maybe<PrincipalInfo>&
principalToInheritInfo() const
{
return principalToInheritInfo_;
}
mozilla::Maybe<PrincipalInfo>&
topLevelPrincipalInfo()
{
return topLevelPrincipalInfo_;
}
const mozilla::Maybe<PrincipalInfo>&
topLevelPrincipalInfo() const
{
return topLevelPrincipalInfo_;
}
mozilla::Maybe<URIParams>&
resultPrincipalURI()
{
return resultPrincipalURI_;
}
const mozilla::Maybe<URIParams>&
resultPrincipalURI() const
{
return resultPrincipalURI_;
}
nsCString&
triggeringRemoteType()
{
return triggeringRemoteType_;
}
const nsCString&
triggeringRemoteType() const
{
return triggeringRemoteType_;
}
nsID&
sandboxedNullPrincipalID()
{
return sandboxedNullPrincipalID_;
}
const nsID&
sandboxedNullPrincipalID() const
{
return sandboxedNullPrincipalID_;
}
uint32_t&
securityFlags()
{
return securityFlags_;
}
const uint32_t&
securityFlags() const
{
return securityFlags_;
}
uint32_t&
sandboxFlags()
{
return sandboxFlags_;
}
const uint32_t&
sandboxFlags() const
{
return sandboxFlags_;
}
uint32_t&
triggeringSandboxFlags()
{
return triggeringSandboxFlags_;
}
const uint32_t&
triggeringSandboxFlags() const
{
return triggeringSandboxFlags_;
}
uint64_t&
triggeringWindowId()
{
return triggeringWindowId_;
}
const uint64_t&
triggeringWindowId() const
{
return triggeringWindowId_;
}
bool&
triggeringStorageAccess()
{
return triggeringStorageAccess_;
}
const bool&
triggeringStorageAccess() const
{
return triggeringStorageAccess_;
}
nsContentPolicyType&
contentPolicyType()
{
return contentPolicyType_;
}
const nsContentPolicyType&
contentPolicyType() const
{
return contentPolicyType_;
}
uint32_t&
tainting()
{
return tainting_;
}
const uint32_t&
tainting() const
{
return tainting_;
}
bool&
blockAllMixedContent()
{
return blockAllMixedContent_;
}
const bool&
blockAllMixedContent() const
{
return blockAllMixedContent_;
}
bool&
upgradeInsecureRequests()
{
return upgradeInsecureRequests_;
}
const bool&
upgradeInsecureRequests() const
{
return upgradeInsecureRequests_;
}
bool&
browserUpgradeInsecureRequests()
{
return browserUpgradeInsecureRequests_;
}
const bool&
browserUpgradeInsecureRequests() const
{
return browserUpgradeInsecureRequests_;
}
bool&
browserDidUpgradeInsecureRequests()
{
return browserDidUpgradeInsecureRequests_;
}
const bool&
browserDidUpgradeInsecureRequests() const
{
return browserDidUpgradeInsecureRequests_;
}
bool&
browserWouldUpgradeInsecureRequests()
{
return browserWouldUpgradeInsecureRequests_;
}
const bool&
browserWouldUpgradeInsecureRequests() const
{
return browserWouldUpgradeInsecureRequests_;
}
bool&
forceAllowDataURI()
{
return forceAllowDataURI_;
}
const bool&
forceAllowDataURI() const
{
return forceAllowDataURI_;
}
bool&
allowInsecureRedirectToDataURI()
{
return allowInsecureRedirectToDataURI_;
}
const bool&
allowInsecureRedirectToDataURI() const
{
return allowInsecureRedirectToDataURI_;
}
bool&
skipContentPolicyCheckForWebRequest()
{
return skipContentPolicyCheckForWebRequest_;
}
const bool&
skipContentPolicyCheckForWebRequest() const
{
return skipContentPolicyCheckForWebRequest_;
}
bool&
originalFrameSrcLoad()
{
return originalFrameSrcLoad_;
}
const bool&
originalFrameSrcLoad() const
{
return originalFrameSrcLoad_;
}
bool&
forceInheritPrincipalDropped()
{
return forceInheritPrincipalDropped_;
}
const bool&
forceInheritPrincipalDropped() const
{
return forceInheritPrincipalDropped_;
}
uint64_t&
innerWindowID()
{
return innerWindowID_;
}
const uint64_t&
innerWindowID() const
{
return innerWindowID_;
}
uint64_t&
browsingContextID()
{
return browsingContextID_;
}
const uint64_t&
browsingContextID() const
{
return browsingContextID_;
}
uint64_t&
frameBrowsingContextID()
{
return frameBrowsingContextID_;
}
const uint64_t&
frameBrowsingContextID() const
{
return frameBrowsingContextID_;
}
bool&
initialSecurityCheckDone()
{
return initialSecurityCheckDone_;
}
const bool&
initialSecurityCheckDone() const
{
return initialSecurityCheckDone_;
}
bool&
isInThirdPartyContext()
{
return isInThirdPartyContext_;
}
const bool&
isInThirdPartyContext() const
{
return isInThirdPartyContext_;
}
mozilla::Maybe<bool>&
isThirdPartyContextToTopWindow()
{
return isThirdPartyContextToTopWindow_;
}
const mozilla::Maybe<bool>&
isThirdPartyContextToTopWindow() const
{
return isThirdPartyContextToTopWindow_;
}
bool&
isFormSubmission()
{
return isFormSubmission_;
}
const bool&
isFormSubmission() const
{
return isFormSubmission_;
}
bool&
isGETRequest()
{
return isGETRequest_;
}
const bool&
isGETRequest() const
{
return isGETRequest_;
}
bool&
sendCSPViolationEvents()
{
return sendCSPViolationEvents_;
}
const bool&
sendCSPViolationEvents() const
{
return sendCSPViolationEvents_;
}
OriginAttributes&
originAttributes()
{
return originAttributes_;
}
const OriginAttributes&
originAttributes() const
{
return originAttributes_;
}
nsTArray<RedirectHistoryEntryInfo>&
redirectChainIncludingInternalRedirects()
{
return redirectChainIncludingInternalRedirects_;
}
const nsTArray<RedirectHistoryEntryInfo>&
redirectChainIncludingInternalRedirects() const
{
return redirectChainIncludingInternalRedirects_;
}
nsTArray<RedirectHistoryEntryInfo>&
redirectChain()
{
return redirectChain_;
}
const nsTArray<RedirectHistoryEntryInfo>&
redirectChain() const
{
return redirectChain_;
}
bool&
hasInjectedCookieForCookieBannerHandling()
{
return hasInjectedCookieForCookieBannerHandling_;
}
const bool&
hasInjectedCookieForCookieBannerHandling() const
{
return hasInjectedCookieForCookieBannerHandling_;
}
SchemelessInputType&
schemelessInput()
{
return schemelessInput_;
}
const SchemelessInputType&
schemelessInput() const
{
return schemelessInput_;
}
HTTPSUpgradeTelemetryType&
httpsUpgradeTelemetry()
{
return httpsUpgradeTelemetry_;
}
const HTTPSUpgradeTelemetryType&
httpsUpgradeTelemetry() const
{
return httpsUpgradeTelemetry_;
}
mozilla::Maybe<IPCClientInfo>&
clientInfo()
{
return clientInfo_;
}
const mozilla::Maybe<IPCClientInfo>&
clientInfo() const
{
return clientInfo_;
}
mozilla::Maybe<IPCClientInfo>&
reservedClientInfo()
{
return reservedClientInfo_;
}
const mozilla::Maybe<IPCClientInfo>&
reservedClientInfo() const
{
return reservedClientInfo_;
}
mozilla::Maybe<IPCClientInfo>&
initialClientInfo()
{
return initialClientInfo_;
}
const mozilla::Maybe<IPCClientInfo>&
initialClientInfo() const
{
return initialClientInfo_;
}
mozilla::Maybe<IPCServiceWorkerDescriptor>&
controller()
{
return controller_;
}
const mozilla::Maybe<IPCServiceWorkerDescriptor>&
controller() const
{
return controller_;
}
nsTArray<nsCString>&
corsUnsafeHeaders()
{
return corsUnsafeHeaders_;
}
const nsTArray<nsCString>&
corsUnsafeHeaders() const
{
return corsUnsafeHeaders_;
}
bool&
forcePreflight()
{
return forcePreflight_;
}
const bool&
forcePreflight() const
{
return forcePreflight_;
}
bool&
isPreflight()
{
return isPreflight_;
}
const bool&
isPreflight() const
{
return isPreflight_;
}
bool&
loadTriggeredFromExternal()
{
return loadTriggeredFromExternal_;
}
const bool&
loadTriggeredFromExternal() const
{
return loadTriggeredFromExternal_;
}
bool&
serviceWorkerTaintingSynthesized()
{
return serviceWorkerTaintingSynthesized_;
}
const bool&
serviceWorkerTaintingSynthesized() const
{
return serviceWorkerTaintingSynthesized_;
}
bool&
documentHasUserInteracted()
{
return documentHasUserInteracted_;
}
const bool&
documentHasUserInteracted() const
{
return documentHasUserInteracted_;
}
bool&
allowListFutureDocumentsCreatedFromThisRedirectChain()
{
return allowListFutureDocumentsCreatedFromThisRedirectChain_;
}
const bool&
allowListFutureDocumentsCreatedFromThisRedirectChain() const
{
return allowListFutureDocumentsCreatedFromThisRedirectChain_;
}
bool&
needForCheckingAntiTrackingHeuristic()
{
return needForCheckingAntiTrackingHeuristic_;
}
const bool&
needForCheckingAntiTrackingHeuristic() const
{
return needForCheckingAntiTrackingHeuristic_;
}
nsString&
cspNonce()
{
return cspNonce_;
}
const nsString&
cspNonce() const
{
return cspNonce_;
}
nsString&
integrityMetadata()
{
return integrityMetadata_;
}
const nsString&
integrityMetadata() const
{
return integrityMetadata_;
}
bool&
skipContentSniffing()
{
return skipContentSniffing_;
}
const bool&
skipContentSniffing() const
{
return skipContentSniffing_;
}
uint32_t&
httpsOnlyStatus()
{
return httpsOnlyStatus_;
}
const uint32_t&
httpsOnlyStatus() const
{
return httpsOnlyStatus_;
}
bool&
hstsStatus()
{
return hstsStatus_;
}
const bool&
hstsStatus() const
{
return hstsStatus_;
}
bool&
hasValidUserGestureActivation()
{
return hasValidUserGestureActivation_;
}
const bool&
hasValidUserGestureActivation() const
{
return hasValidUserGestureActivation_;
}
bool&
textDirectiveUserActivation()
{
return textDirectiveUserActivation_;
}
const bool&
textDirectiveUserActivation() const
{
return textDirectiveUserActivation_;
}
bool&
allowDeprecatedSystemRequests()
{
return allowDeprecatedSystemRequests_;
}
const bool&
allowDeprecatedSystemRequests() const
{
return allowDeprecatedSystemRequests_;
}
bool&
isInDevToolsContext()
{
return isInDevToolsContext_;
}
const bool&
isInDevToolsContext() const
{
return isInDevToolsContext_;
}
bool&
parserCreatedScript()
{
return parserCreatedScript_;
}
const bool&
parserCreatedScript() const
{
return parserCreatedScript_;
}
bool&
isFromProcessingFrameAttributes()
{
return isFromProcessingFrameAttributes_;
}
const bool&
isFromProcessingFrameAttributes() const
{
return isFromProcessingFrameAttributes_;
}
bool&
isMediaRequest()
{
return isMediaRequest_;
}
const bool&
isMediaRequest() const
{
return isMediaRequest_;
}
bool&
isMediaInitialRequest()
{
return isMediaInitialRequest_;
}
const bool&
isMediaInitialRequest() const
{
return isMediaInitialRequest_;
}
bool&
isFromObjectOrEmbed()
{
return isFromObjectOrEmbed_;
}
const bool&
isFromObjectOrEmbed() const
{
return isFromObjectOrEmbed_;
}
CookieJarSettingsArgs&
cookieJarSettings()
{
return cookieJarSettings_;
}
const CookieJarSettingsArgs&
cookieJarSettings() const
{
return cookieJarSettings_;
}
uint32_t&
requestBlockingReason()
{
return requestBlockingReason_;
}
const uint32_t&
requestBlockingReason() const
{
return requestBlockingReason_;
}
mozilla::Maybe<CSPInfo>&
cspToInheritInfo()
{
return cspToInheritInfo_;
}
const mozilla::Maybe<CSPInfo>&
cspToInheritInfo() const
{
return cspToInheritInfo_;
}
StoragePermissionState&
storagePermission()
{
return storagePermission_;
}
const StoragePermissionState&
storagePermission() const
{
return storagePermission_;
}
mozilla::Maybe<uint64_t>&
overriddenFingerprintingSettings()
{
return overriddenFingerprintingSettings_;
}
const mozilla::Maybe<uint64_t>&
overriddenFingerprintingSettings() const
{
return overriddenFingerprintingSettings_;
}
bool&
isMetaRefresh()
{
return isMetaRefresh_;
}
const bool&
isMetaRefresh() const
{
return isMetaRefresh_;
}
CrossOriginEmbedderPolicy&
loadingEmbedderPolicy()
{
return loadingEmbedderPolicy_;
}
const CrossOriginEmbedderPolicy&
loadingEmbedderPolicy() const
{
return loadingEmbedderPolicy_;
}
bool&
originTrialCoepCredentiallessEnabledForTopLevel()
{
return originTrialCoepCredentiallessEnabledForTopLevel_;
}
const bool&
originTrialCoepCredentiallessEnabledForTopLevel() const
{
return originTrialCoepCredentiallessEnabledForTopLevel_;
}
RefPtr<nsIURI>&
unstrippedURI()
{
return unstrippedURI_;
}
nsIURI*
unstrippedURI() const
{
return unstrippedURI_;
}
mozilla::Maybe<InterceptionInfoArg>&
interceptionInfo()
{
return interceptionInfo_;
}
const mozilla::Maybe<InterceptionInfoArg>&
interceptionInfo() const
{
return interceptionInfo_;
}
bool&
isNewWindowTarget()
{
return isNewWindowTarget_;
}
const bool&
isNewWindowTarget() const
{
return isNewWindowTarget_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> requestingPrincipalInfo_;
::mozilla::ipc::IPDLStructMember<PrincipalInfo> triggeringPrincipalInfo_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> principalToInheritInfo_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> topLevelPrincipalInfo_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<URIParams>> resultPrincipalURI_;
::mozilla::ipc::IPDLStructMember<nsCString> triggeringRemoteType_;
::mozilla::ipc::IPDLStructMember<nsID> sandboxedNullPrincipalID_;
::mozilla::ipc::IPDLStructMember<bool> triggeringStorageAccess_;
::mozilla::ipc::IPDLStructMember<nsContentPolicyType> contentPolicyType_;
::mozilla::ipc::IPDLStructMember<bool> blockAllMixedContent_;
::mozilla::ipc::IPDLStructMember<bool> upgradeInsecureRequests_;
::mozilla::ipc::IPDLStructMember<bool> browserUpgradeInsecureRequests_;
::mozilla::ipc::IPDLStructMember<bool> browserDidUpgradeInsecureRequests_;
::mozilla::ipc::IPDLStructMember<bool> browserWouldUpgradeInsecureRequests_;
::mozilla::ipc::IPDLStructMember<bool> forceAllowDataURI_;
::mozilla::ipc::IPDLStructMember<bool> allowInsecureRedirectToDataURI_;
::mozilla::ipc::IPDLStructMember<bool> skipContentPolicyCheckForWebRequest_;
::mozilla::ipc::IPDLStructMember<bool> originalFrameSrcLoad_;
::mozilla::ipc::IPDLStructMember<bool> forceInheritPrincipalDropped_;
::mozilla::ipc::IPDLStructMember<bool> initialSecurityCheckDone_;
::mozilla::ipc::IPDLStructMember<bool> isInThirdPartyContext_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<bool>> isThirdPartyContextToTopWindow_;
::mozilla::ipc::IPDLStructMember<bool> isFormSubmission_;
::mozilla::ipc::IPDLStructMember<bool> isGETRequest_;
::mozilla::ipc::IPDLStructMember<bool> sendCSPViolationEvents_;
::mozilla::ipc::IPDLStructMember<OriginAttributes> originAttributes_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<RedirectHistoryEntryInfo>> redirectChainIncludingInternalRedirects_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<RedirectHistoryEntryInfo>> redirectChain_;
::mozilla::ipc::IPDLStructMember<bool> hasInjectedCookieForCookieBannerHandling_;
::mozilla::ipc::IPDLStructMember<SchemelessInputType> schemelessInput_;
::mozilla::ipc::IPDLStructMember<HTTPSUpgradeTelemetryType> httpsUpgradeTelemetry_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> clientInfo_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> reservedClientInfo_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> initialClientInfo_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCServiceWorkerDescriptor>> controller_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<nsCString>> corsUnsafeHeaders_;
::mozilla::ipc::IPDLStructMember<bool> forcePreflight_;
::mozilla::ipc::IPDLStructMember<bool> isPreflight_;
::mozilla::ipc::IPDLStructMember<bool> loadTriggeredFromExternal_;
::mozilla::ipc::IPDLStructMember<bool> serviceWorkerTaintingSynthesized_;
::mozilla::ipc::IPDLStructMember<bool> documentHasUserInteracted_;
::mozilla::ipc::IPDLStructMember<bool> allowListFutureDocumentsCreatedFromThisRedirectChain_;
::mozilla::ipc::IPDLStructMember<bool> needForCheckingAntiTrackingHeuristic_;
::mozilla::ipc::IPDLStructMember<nsString> cspNonce_;
::mozilla::ipc::IPDLStructMember<nsString> integrityMetadata_;
::mozilla::ipc::IPDLStructMember<bool> skipContentSniffing_;
::mozilla::ipc::IPDLStructMember<bool> hstsStatus_;
::mozilla::ipc::IPDLStructMember<bool> hasValidUserGestureActivation_;
::mozilla::ipc::IPDLStructMember<bool> textDirectiveUserActivation_;
::mozilla::ipc::IPDLStructMember<bool> allowDeprecatedSystemRequests_;
::mozilla::ipc::IPDLStructMember<bool> isInDevToolsContext_;
::mozilla::ipc::IPDLStructMember<bool> parserCreatedScript_;
::mozilla::ipc::IPDLStructMember<bool> isFromProcessingFrameAttributes_;
::mozilla::ipc::IPDLStructMember<bool> isMediaRequest_;
::mozilla::ipc::IPDLStructMember<bool> isMediaInitialRequest_;
::mozilla::ipc::IPDLStructMember<bool> isFromObjectOrEmbed_;
::mozilla::ipc::IPDLStructMember<CookieJarSettingsArgs> cookieJarSettings_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<CSPInfo>> cspToInheritInfo_;
::mozilla::ipc::IPDLStructMember<StoragePermissionState> storagePermission_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<uint64_t>> overriddenFingerprintingSettings_;
::mozilla::ipc::IPDLStructMember<bool> isMetaRefresh_;
::mozilla::ipc::IPDLStructMember<CrossOriginEmbedderPolicy> loadingEmbedderPolicy_;
::mozilla::ipc::IPDLStructMember<bool> originTrialCoepCredentiallessEnabledForTopLevel_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> unstrippedURI_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<InterceptionInfoArg>> interceptionInfo_;
::mozilla::ipc::IPDLStructMember<bool> isNewWindowTarget_;
::mozilla::ipc::IPDLStructMember<uint64_t> triggeringWindowId_;
::mozilla::ipc::IPDLStructMember<uint64_t> innerWindowID_;
::mozilla::ipc::IPDLStructMember<uint64_t> browsingContextID_;
::mozilla::ipc::IPDLStructMember<uint64_t> frameBrowsingContextID_;
::mozilla::ipc::IPDLStructMember<uint32_t> securityFlags_;
::mozilla::ipc::IPDLStructMember<uint32_t> sandboxFlags_;
::mozilla::ipc::IPDLStructMember<uint32_t> triggeringSandboxFlags_;
::mozilla::ipc::IPDLStructMember<uint32_t> tainting_;
::mozilla::ipc::IPDLStructMember<uint32_t> httpsOnlyStatus_;
::mozilla::ipc::IPDLStructMember<uint32_t> requestBlockingReason_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::LoadInfoArgs>
{
typedef ::mozilla::net::LoadInfoArgs 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 ParentLoadInfoForwarderArgs|
//
namespace mozilla {
namespace net {
class ParentLoadInfoForwarderArgs final
{
private:
typedef ::mozilla::dom::IPCServiceWorkerDescriptor IPCServiceWorkerDescriptor;
typedef ::uint32_t uint32_t;
typedef ::nsILoadInfo::SchemelessInputType SchemelessInputType;
typedef ::nsILoadInfo::HTTPSUpgradeTelemetryType HTTPSUpgradeTelemetryType;
typedef ::uint64_t uint64_t;
typedef ::mozilla::net::CookieJarSettingsArgs CookieJarSettingsArgs;
typedef ::mozilla::dom::FeaturePolicyInfo FeaturePolicyInfo;
typedef ::nsILoadInfo::StoragePermissionState StoragePermissionState;
typedef ::nsIURI nsIURI;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ParentLoadInfoForwarderArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ParentLoadInfoForwarderArgs(
const bool& _allowInsecureRedirectToDataURI,
const mozilla::Maybe<IPCServiceWorkerDescriptor>& _controller,
const uint32_t& _tainting,
const bool& _skipContentSniffing,
const uint32_t& _httpsOnlyStatus,
const SchemelessInputType& _schemelessInput,
const HTTPSUpgradeTelemetryType& _httpsUpgradeTelemetry,
const bool& _hstsStatus,
const bool& _hasValidUserGestureActivation,
const bool& _textDirectiveUserActivation,
const bool& _allowDeprecatedSystemRequests,
const bool& _isInDevToolsContext,
const bool& _parserCreatedScript,
const uint32_t& _triggeringSandboxFlags,
const uint64_t& _triggeringWindowId,
const bool& _triggeringStorageAccess,
const bool& _serviceWorkerTaintingSynthesized,
const bool& _documentHasUserInteracted,
const bool& _allowListFutureDocumentsCreatedFromThisRedirectChain,
const mozilla::Maybe<CookieJarSettingsArgs>& _cookieJarSettings,
const mozilla::Maybe<FeaturePolicyInfo>& _containerFeaturePolicyInfo,
const uint32_t& _requestBlockingReason,
const StoragePermissionState& _storagePermission,
const mozilla::Maybe<uint64_t>& _overriddenFingerprintingSettings,
const bool& _isMetaRefresh,
const mozilla::Maybe<bool>& _isThirdPartyContextToTopWindow,
const bool& _isInThirdPartyContext,
nsIURI* _unstrippedURI) :
allowInsecureRedirectToDataURI_(_allowInsecureRedirectToDataURI),
controller_(_controller),
skipContentSniffing_(_skipContentSniffing),
schemelessInput_(_schemelessInput),
httpsUpgradeTelemetry_(_httpsUpgradeTelemetry),
hstsStatus_(_hstsStatus),
hasValidUserGestureActivation_(_hasValidUserGestureActivation),
textDirectiveUserActivation_(_textDirectiveUserActivation),
allowDeprecatedSystemRequests_(_allowDeprecatedSystemRequests),
isInDevToolsContext_(_isInDevToolsContext),
parserCreatedScript_(_parserCreatedScript),
triggeringStorageAccess_(_triggeringStorageAccess),
serviceWorkerTaintingSynthesized_(_serviceWorkerTaintingSynthesized),
documentHasUserInteracted_(_documentHasUserInteracted),
allowListFutureDocumentsCreatedFromThisRedirectChain_(_allowListFutureDocumentsCreatedFromThisRedirectChain),
cookieJarSettings_(_cookieJarSettings),
containerFeaturePolicyInfo_(_containerFeaturePolicyInfo),
storagePermission_(_storagePermission),
overriddenFingerprintingSettings_(_overriddenFingerprintingSettings),
isMetaRefresh_(_isMetaRefresh),
isThirdPartyContextToTopWindow_(_isThirdPartyContextToTopWindow),
isInThirdPartyContext_(_isInThirdPartyContext),
unstrippedURI_(_unstrippedURI),
triggeringWindowId_(_triggeringWindowId),
tainting_(_tainting),
httpsOnlyStatus_(_httpsOnlyStatus),
triggeringSandboxFlags_(_triggeringSandboxFlags),
requestBlockingReason_(_requestBlockingReason)
{
}
MOZ_IMPLICIT ParentLoadInfoForwarderArgs(
bool&& _allowInsecureRedirectToDataURI,
mozilla::Maybe<IPCServiceWorkerDescriptor>&& _controller,
uint32_t&& _tainting,
bool&& _skipContentSniffing,
uint32_t&& _httpsOnlyStatus,
SchemelessInputType&& _schemelessInput,
HTTPSUpgradeTelemetryType&& _httpsUpgradeTelemetry,
bool&& _hstsStatus,
bool&& _hasValidUserGestureActivation,
bool&& _textDirectiveUserActivation,
bool&& _allowDeprecatedSystemRequests,
bool&& _isInDevToolsContext,
bool&& _parserCreatedScript,
uint32_t&& _triggeringSandboxFlags,
uint64_t&& _triggeringWindowId,
bool&& _triggeringStorageAccess,
bool&& _serviceWorkerTaintingSynthesized,
bool&& _documentHasUserInteracted,
bool&& _allowListFutureDocumentsCreatedFromThisRedirectChain,
mozilla::Maybe<CookieJarSettingsArgs>&& _cookieJarSettings,
mozilla::Maybe<FeaturePolicyInfo>&& _containerFeaturePolicyInfo,
uint32_t&& _requestBlockingReason,
StoragePermissionState&& _storagePermission,
mozilla::Maybe<uint64_t>&& _overriddenFingerprintingSettings,
bool&& _isMetaRefresh,
mozilla::Maybe<bool>&& _isThirdPartyContextToTopWindow,
bool&& _isInThirdPartyContext,
RefPtr<nsIURI>&& _unstrippedURI) :
allowInsecureRedirectToDataURI_(std::move(_allowInsecureRedirectToDataURI)),
controller_(std::move(_controller)),
skipContentSniffing_(std::move(_skipContentSniffing)),
schemelessInput_(std::move(_schemelessInput)),
httpsUpgradeTelemetry_(std::move(_httpsUpgradeTelemetry)),
hstsStatus_(std::move(_hstsStatus)),
hasValidUserGestureActivation_(std::move(_hasValidUserGestureActivation)),
textDirectiveUserActivation_(std::move(_textDirectiveUserActivation)),
allowDeprecatedSystemRequests_(std::move(_allowDeprecatedSystemRequests)),
isInDevToolsContext_(std::move(_isInDevToolsContext)),
parserCreatedScript_(std::move(_parserCreatedScript)),
triggeringStorageAccess_(std::move(_triggeringStorageAccess)),
serviceWorkerTaintingSynthesized_(std::move(_serviceWorkerTaintingSynthesized)),
documentHasUserInteracted_(std::move(_documentHasUserInteracted)),
allowListFutureDocumentsCreatedFromThisRedirectChain_(std::move(_allowListFutureDocumentsCreatedFromThisRedirectChain)),
cookieJarSettings_(std::move(_cookieJarSettings)),
containerFeaturePolicyInfo_(std::move(_containerFeaturePolicyInfo)),
storagePermission_(std::move(_storagePermission)),
overriddenFingerprintingSettings_(std::move(_overriddenFingerprintingSettings)),
isMetaRefresh_(std::move(_isMetaRefresh)),
isThirdPartyContextToTopWindow_(std::move(_isThirdPartyContextToTopWindow)),
isInThirdPartyContext_(std::move(_isInThirdPartyContext)),
unstrippedURI_(std::move(_unstrippedURI)),
triggeringWindowId_(std::move(_triggeringWindowId)),
tainting_(std::move(_tainting)),
httpsOnlyStatus_(std::move(_httpsOnlyStatus)),
triggeringSandboxFlags_(std::move(_triggeringSandboxFlags)),
requestBlockingReason_(std::move(_requestBlockingReason))
{
}
bool&
allowInsecureRedirectToDataURI()
{
return allowInsecureRedirectToDataURI_;
}
const bool&
allowInsecureRedirectToDataURI() const
{
return allowInsecureRedirectToDataURI_;
}
mozilla::Maybe<IPCServiceWorkerDescriptor>&
controller()
{
return controller_;
}
const mozilla::Maybe<IPCServiceWorkerDescriptor>&
controller() const
{
return controller_;
}
uint32_t&
tainting()
{
return tainting_;
}
const uint32_t&
tainting() const
{
return tainting_;
}
bool&
skipContentSniffing()
{
return skipContentSniffing_;
}
const bool&
skipContentSniffing() const
{
return skipContentSniffing_;
}
uint32_t&
httpsOnlyStatus()
{
return httpsOnlyStatus_;
}
const uint32_t&
httpsOnlyStatus() const
{
return httpsOnlyStatus_;
}
SchemelessInputType&
schemelessInput()
{
return schemelessInput_;
}
const SchemelessInputType&
schemelessInput() const
{
return schemelessInput_;
}
HTTPSUpgradeTelemetryType&
httpsUpgradeTelemetry()
{
return httpsUpgradeTelemetry_;
}
const HTTPSUpgradeTelemetryType&
httpsUpgradeTelemetry() const
{
return httpsUpgradeTelemetry_;
}
bool&
hstsStatus()
{
return hstsStatus_;
}
const bool&
hstsStatus() const
{
return hstsStatus_;
}
bool&
hasValidUserGestureActivation()
{
return hasValidUserGestureActivation_;
}
const bool&
hasValidUserGestureActivation() const
{
return hasValidUserGestureActivation_;
}
bool&
textDirectiveUserActivation()
{
return textDirectiveUserActivation_;
}
const bool&
textDirectiveUserActivation() const
{
return textDirectiveUserActivation_;
}
bool&
allowDeprecatedSystemRequests()
{
return allowDeprecatedSystemRequests_;
}
const bool&
allowDeprecatedSystemRequests() const
{
return allowDeprecatedSystemRequests_;
}
bool&
isInDevToolsContext()
{
return isInDevToolsContext_;
}
const bool&
isInDevToolsContext() const
{
return isInDevToolsContext_;
}
bool&
parserCreatedScript()
{
return parserCreatedScript_;
}
const bool&
parserCreatedScript() const
{
return parserCreatedScript_;
}
uint32_t&
triggeringSandboxFlags()
{
return triggeringSandboxFlags_;
}
const uint32_t&
triggeringSandboxFlags() const
{
return triggeringSandboxFlags_;
}
uint64_t&
triggeringWindowId()
{
return triggeringWindowId_;
}
const uint64_t&
triggeringWindowId() const
{
return triggeringWindowId_;
}
bool&
triggeringStorageAccess()
{
return triggeringStorageAccess_;
}
const bool&
triggeringStorageAccess() const
{
return triggeringStorageAccess_;
}
bool&
serviceWorkerTaintingSynthesized()
{
return serviceWorkerTaintingSynthesized_;
}
const bool&
serviceWorkerTaintingSynthesized() const
{
return serviceWorkerTaintingSynthesized_;
}
bool&
documentHasUserInteracted()
{
return documentHasUserInteracted_;
}
const bool&
documentHasUserInteracted() const
{
return documentHasUserInteracted_;
}
bool&
allowListFutureDocumentsCreatedFromThisRedirectChain()
{
return allowListFutureDocumentsCreatedFromThisRedirectChain_;
}
const bool&
allowListFutureDocumentsCreatedFromThisRedirectChain() const
{
return allowListFutureDocumentsCreatedFromThisRedirectChain_;
}
mozilla::Maybe<CookieJarSettingsArgs>&
cookieJarSettings()
{
return cookieJarSettings_;
}
const mozilla::Maybe<CookieJarSettingsArgs>&
cookieJarSettings() const
{
return cookieJarSettings_;
}
mozilla::Maybe<FeaturePolicyInfo>&
containerFeaturePolicyInfo()
{
return containerFeaturePolicyInfo_;
}
const mozilla::Maybe<FeaturePolicyInfo>&
containerFeaturePolicyInfo() const
{
return containerFeaturePolicyInfo_;
}
uint32_t&
requestBlockingReason()
{
return requestBlockingReason_;
}
const uint32_t&
requestBlockingReason() const
{
return requestBlockingReason_;
}
StoragePermissionState&
storagePermission()
{
return storagePermission_;
}
const StoragePermissionState&
storagePermission() const
{
return storagePermission_;
}
mozilla::Maybe<uint64_t>&
overriddenFingerprintingSettings()
{
return overriddenFingerprintingSettings_;
}
const mozilla::Maybe<uint64_t>&
overriddenFingerprintingSettings() const
{
return overriddenFingerprintingSettings_;
}
bool&
isMetaRefresh()
{
return isMetaRefresh_;
}
const bool&
isMetaRefresh() const
{
return isMetaRefresh_;
}
mozilla::Maybe<bool>&
isThirdPartyContextToTopWindow()
{
return isThirdPartyContextToTopWindow_;
}
const mozilla::Maybe<bool>&
isThirdPartyContextToTopWindow() const
{
return isThirdPartyContextToTopWindow_;
}
bool&
isInThirdPartyContext()
{
return isInThirdPartyContext_;
}
const bool&
isInThirdPartyContext() const
{
return isInThirdPartyContext_;
}
RefPtr<nsIURI>&
unstrippedURI()
{
return unstrippedURI_;
}
nsIURI*
unstrippedURI() const
{
return unstrippedURI_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<bool> allowInsecureRedirectToDataURI_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCServiceWorkerDescriptor>> controller_;
::mozilla::ipc::IPDLStructMember<bool> skipContentSniffing_;
::mozilla::ipc::IPDLStructMember<SchemelessInputType> schemelessInput_;
::mozilla::ipc::IPDLStructMember<HTTPSUpgradeTelemetryType> httpsUpgradeTelemetry_;
::mozilla::ipc::IPDLStructMember<bool> hstsStatus_;
::mozilla::ipc::IPDLStructMember<bool> hasValidUserGestureActivation_;
::mozilla::ipc::IPDLStructMember<bool> textDirectiveUserActivation_;
::mozilla::ipc::IPDLStructMember<bool> allowDeprecatedSystemRequests_;
::mozilla::ipc::IPDLStructMember<bool> isInDevToolsContext_;
::mozilla::ipc::IPDLStructMember<bool> parserCreatedScript_;
::mozilla::ipc::IPDLStructMember<bool> triggeringStorageAccess_;
::mozilla::ipc::IPDLStructMember<bool> serviceWorkerTaintingSynthesized_;
::mozilla::ipc::IPDLStructMember<bool> documentHasUserInteracted_;
::mozilla::ipc::IPDLStructMember<bool> allowListFutureDocumentsCreatedFromThisRedirectChain_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<CookieJarSettingsArgs>> cookieJarSettings_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<FeaturePolicyInfo>> containerFeaturePolicyInfo_;
::mozilla::ipc::IPDLStructMember<StoragePermissionState> storagePermission_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<uint64_t>> overriddenFingerprintingSettings_;
::mozilla::ipc::IPDLStructMember<bool> isMetaRefresh_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<bool>> isThirdPartyContextToTopWindow_;
::mozilla::ipc::IPDLStructMember<bool> isInThirdPartyContext_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> unstrippedURI_;
::mozilla::ipc::IPDLStructMember<uint64_t> triggeringWindowId_;
::mozilla::ipc::IPDLStructMember<uint32_t> tainting_;
::mozilla::ipc::IPDLStructMember<uint32_t> httpsOnlyStatus_;
::mozilla::ipc::IPDLStructMember<uint32_t> triggeringSandboxFlags_;
::mozilla::ipc::IPDLStructMember<uint32_t> requestBlockingReason_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::ParentLoadInfoForwarderArgs>
{
typedef ::mozilla::net::ParentLoadInfoForwarderArgs 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 ChildLoadInfoForwarderArgs|
//
namespace mozilla {
namespace net {
class ChildLoadInfoForwarderArgs final
{
private:
typedef ::mozilla::dom::IPCClientInfo IPCClientInfo;
typedef ::mozilla::dom::IPCServiceWorkerDescriptor IPCServiceWorkerDescriptor;
typedef ::uint32_t uint32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ChildLoadInfoForwarderArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ChildLoadInfoForwarderArgs(
const mozilla::Maybe<IPCClientInfo>& _reservedClientInfo,
const mozilla::Maybe<IPCClientInfo>& _initialClientInfo,
const mozilla::Maybe<IPCServiceWorkerDescriptor>& _controller,
const uint32_t& _requestBlockingReason) :
reservedClientInfo_(_reservedClientInfo),
initialClientInfo_(_initialClientInfo),
controller_(_controller),
requestBlockingReason_(_requestBlockingReason)
{
}
MOZ_IMPLICIT ChildLoadInfoForwarderArgs(
mozilla::Maybe<IPCClientInfo>&& _reservedClientInfo,
mozilla::Maybe<IPCClientInfo>&& _initialClientInfo,
mozilla::Maybe<IPCServiceWorkerDescriptor>&& _controller,
uint32_t&& _requestBlockingReason) :
reservedClientInfo_(std::move(_reservedClientInfo)),
initialClientInfo_(std::move(_initialClientInfo)),
controller_(std::move(_controller)),
requestBlockingReason_(std::move(_requestBlockingReason))
{
}
mozilla::Maybe<IPCClientInfo>&
reservedClientInfo()
{
return reservedClientInfo_;
}
const mozilla::Maybe<IPCClientInfo>&
reservedClientInfo() const
{
return reservedClientInfo_;
}
mozilla::Maybe<IPCClientInfo>&
initialClientInfo()
{
return initialClientInfo_;
}
const mozilla::Maybe<IPCClientInfo>&
initialClientInfo() const
{
return initialClientInfo_;
}
mozilla::Maybe<IPCServiceWorkerDescriptor>&
controller()
{
return controller_;
}
const mozilla::Maybe<IPCServiceWorkerDescriptor>&
controller() const
{
return controller_;
}
uint32_t&
requestBlockingReason()
{
return requestBlockingReason_;
}
const uint32_t&
requestBlockingReason() const
{
return requestBlockingReason_;
}
private:
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> reservedClientInfo_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> initialClientInfo_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCServiceWorkerDescriptor>> controller_;
::mozilla::ipc::IPDLStructMember<uint32_t> requestBlockingReason_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::ChildLoadInfoForwarderArgs>
{
typedef ::mozilla::net::ChildLoadInfoForwarderArgs 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 CorsPreflightArgs|
//
namespace mozilla {
namespace net {
class CorsPreflightArgs final
{
private:
typedef ::nsCString nsCString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
CorsPreflightArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CorsPreflightArgs(const nsTArray<nsCString>& _unsafeHeaders) :
unsafeHeaders_(_unsafeHeaders)
{
}
MOZ_IMPLICIT CorsPreflightArgs(nsTArray<nsCString>&& _unsafeHeaders) :
unsafeHeaders_(std::move(_unsafeHeaders))
{
}
nsTArray<nsCString>&
unsafeHeaders()
{
return unsafeHeaders_;
}
const nsTArray<nsCString>&
unsafeHeaders() const
{
return unsafeHeaders_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<nsCString>> unsafeHeaders_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::CorsPreflightArgs>
{
typedef ::mozilla::net::CorsPreflightArgs 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 HttpChannelOpenArgs|
//
namespace mozilla {
namespace net {
class HttpChannelOpenArgs final
{
private:
typedef ::nsIURI nsIURI;
typedef ::nsIReferrerInfo nsIReferrerInfo;
typedef ::mozilla::net::RequestHeaderTuples RequestHeaderTuples;
typedef ::mozilla::net::PreferredAlternativeDataTypeParams PreferredAlternativeDataTypeParams;
typedef ::mozilla::TimeStamp TimeStamp;
typedef ::uint64_t uint64_t;
typedef ::nsCString nsCString;
typedef ::mozilla::net::ClassOfService ClassOfService;
typedef ::mozilla::net::CorsPreflightArgs CorsPreflightArgs;
typedef ::nsString nsString;
typedef ::mozilla::ipc::IPCStream IPCStream;
typedef ::mozilla::net::LoadInfoArgs LoadInfoArgs;
typedef ::uint32_t uint32_t;
typedef ::int16_t int16_t;
typedef ::mozilla::dom::RequestMode RequestMode;
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
HttpChannelOpenArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT HttpChannelOpenArgs(
nsIURI* _uri,
nsIURI* _original,
nsIURI* _doc,
nsIReferrerInfo* _referrerInfo,
nsIURI* _apiRedirectTo,
nsIURI* _topWindowURI,
const RequestHeaderTuples& _requestHeaders,
const nsTArray<PreferredAlternativeDataTypeParams>& _preferredAlternativeTypes,
const TimeStamp& _launchServiceWorkerStart,
const TimeStamp& _launchServiceWorkerEnd,
const TimeStamp& _dispatchFetchEventStart,
const TimeStamp& _dispatchFetchEventEnd,
const TimeStamp& _handleFetchEventStart,
const TimeStamp& _handleFetchEventEnd,
const TimeStamp& _navigationStartTimeStamp,
const uint64_t& _startPos,
const uint64_t& _requestContextID,
const uint64_t& _channelId,
const uint64_t& _contentWindowId,
const uint64_t& _browserId,
const uint64_t& _earlyHintPreloaderId,
const nsCString& _requestMethod,
const ClassOfService& _classOfService,
const nsCString& _entityID,
const nsCString& _appCacheClientID,
const mozilla::Maybe<CorsPreflightArgs>& _preflightArgs,
const nsCString& _contentTypeHint,
const nsString& _integrityMetadata,
const mozilla::Maybe<IPCStream>& _uploadStream,
const LoadInfoArgs& _loadInfo,
const uint32_t& _loadFlags,
const uint32_t& _thirdPartyFlags,
const uint32_t& _tlsFlags,
const uint32_t& _cacheKey,
const uint32_t& _initialRwin,
const uint32_t& _redirectMode,
const int16_t& _priority,
const bool& _uploadStreamHasHeaders,
const bool& _allowSTS,
const bool& _resumeAt,
const bool& _allowSpdy,
const bool& _allowHttp3,
const bool& _allowAltSvc,
const bool& _beConservative,
const bool& _bypassProxy,
const bool& _blockAuthPrompt,
const bool& _allowStaleCacheContent,
const RequestMode& _requestMode,
const bool& _forceValidateCacheContent,
const bool& _preferCacheLoadOverBypass,
const bool& _forceMainDocumentChannel,
const uint8_t& _redirectionLimit,
const nsString& _classicScriptHintCharset,
const nsString& _documentCharacterSet,
const bool& _isUserAgentHeaderModified,
const nsString& _initiatorType) :
uri_(_uri),
original_(_original),
doc_(_doc),
referrerInfo_(_referrerInfo),
apiRedirectTo_(_apiRedirectTo),
topWindowURI_(_topWindowURI),
requestHeaders_(_requestHeaders),
preferredAlternativeTypes_(_preferredAlternativeTypes),
launchServiceWorkerStart_(_launchServiceWorkerStart),
launchServiceWorkerEnd_(_launchServiceWorkerEnd),
dispatchFetchEventStart_(_dispatchFetchEventStart),
dispatchFetchEventEnd_(_dispatchFetchEventEnd),
handleFetchEventStart_(_handleFetchEventStart),
handleFetchEventEnd_(_handleFetchEventEnd),
navigationStartTimeStamp_(_navigationStartTimeStamp),
requestMethod_(_requestMethod),
classOfService_(_classOfService),
entityID_(_entityID),
appCacheClientID_(_appCacheClientID),
preflightArgs_(_preflightArgs),
contentTypeHint_(_contentTypeHint),
integrityMetadata_(_integrityMetadata),
uploadStream_(_uploadStream),
loadInfo_(_loadInfo),
uploadStreamHasHeaders_(_uploadStreamHasHeaders),
allowSTS_(_allowSTS),
resumeAt_(_resumeAt),
allowSpdy_(_allowSpdy),
allowHttp3_(_allowHttp3),
allowAltSvc_(_allowAltSvc),
beConservative_(_beConservative),
bypassProxy_(_bypassProxy),
blockAuthPrompt_(_blockAuthPrompt),
allowStaleCacheContent_(_allowStaleCacheContent),
requestMode_(_requestMode),
forceValidateCacheContent_(_forceValidateCacheContent),
preferCacheLoadOverBypass_(_preferCacheLoadOverBypass),
forceMainDocumentChannel_(_forceMainDocumentChannel),
classicScriptHintCharset_(_classicScriptHintCharset),
documentCharacterSet_(_documentCharacterSet),
isUserAgentHeaderModified_(_isUserAgentHeaderModified),
initiatorType_(_initiatorType),
startPos_(_startPos),
requestContextID_(_requestContextID),
channelId_(_channelId),
contentWindowId_(_contentWindowId),
browserId_(_browserId),
earlyHintPreloaderId_(_earlyHintPreloaderId),
loadFlags_(_loadFlags),
thirdPartyFlags_(_thirdPartyFlags),
tlsFlags_(_tlsFlags),
cacheKey_(_cacheKey),
initialRwin_(_initialRwin),
redirectMode_(_redirectMode),
priority_(_priority),
redirectionLimit_(_redirectionLimit)
{
}
MOZ_IMPLICIT HttpChannelOpenArgs(
RefPtr<nsIURI>&& _uri,
RefPtr<nsIURI>&& _original,
RefPtr<nsIURI>&& _doc,
RefPtr<nsIReferrerInfo>&& _referrerInfo,
RefPtr<nsIURI>&& _apiRedirectTo,
RefPtr<nsIURI>&& _topWindowURI,
RequestHeaderTuples&& _requestHeaders,
nsTArray<PreferredAlternativeDataTypeParams>&& _preferredAlternativeTypes,
TimeStamp&& _launchServiceWorkerStart,
TimeStamp&& _launchServiceWorkerEnd,
TimeStamp&& _dispatchFetchEventStart,
TimeStamp&& _dispatchFetchEventEnd,
TimeStamp&& _handleFetchEventStart,
TimeStamp&& _handleFetchEventEnd,
TimeStamp&& _navigationStartTimeStamp,
uint64_t&& _startPos,
uint64_t&& _requestContextID,
uint64_t&& _channelId,
uint64_t&& _contentWindowId,
uint64_t&& _browserId,
uint64_t&& _earlyHintPreloaderId,
nsCString&& _requestMethod,
ClassOfService&& _classOfService,
nsCString&& _entityID,
nsCString&& _appCacheClientID,
mozilla::Maybe<CorsPreflightArgs>&& _preflightArgs,
nsCString&& _contentTypeHint,
nsString&& _integrityMetadata,
mozilla::Maybe<IPCStream>&& _uploadStream,
LoadInfoArgs&& _loadInfo,
uint32_t&& _loadFlags,
uint32_t&& _thirdPartyFlags,
uint32_t&& _tlsFlags,
uint32_t&& _cacheKey,
uint32_t&& _initialRwin,
uint32_t&& _redirectMode,
int16_t&& _priority,
bool&& _uploadStreamHasHeaders,
bool&& _allowSTS,
bool&& _resumeAt,
bool&& _allowSpdy,
bool&& _allowHttp3,
bool&& _allowAltSvc,
bool&& _beConservative,
bool&& _bypassProxy,
bool&& _blockAuthPrompt,
bool&& _allowStaleCacheContent,
RequestMode&& _requestMode,
bool&& _forceValidateCacheContent,
bool&& _preferCacheLoadOverBypass,
bool&& _forceMainDocumentChannel,
uint8_t&& _redirectionLimit,
nsString&& _classicScriptHintCharset,
nsString&& _documentCharacterSet,
bool&& _isUserAgentHeaderModified,
nsString&& _initiatorType) :
uri_(std::move(_uri)),
original_(std::move(_original)),
doc_(std::move(_doc)),
referrerInfo_(std::move(_referrerInfo)),
apiRedirectTo_(std::move(_apiRedirectTo)),
topWindowURI_(std::move(_topWindowURI)),
requestHeaders_(std::move(_requestHeaders)),
preferredAlternativeTypes_(std::move(_preferredAlternativeTypes)),
launchServiceWorkerStart_(std::move(_launchServiceWorkerStart)),
launchServiceWorkerEnd_(std::move(_launchServiceWorkerEnd)),
dispatchFetchEventStart_(std::move(_dispatchFetchEventStart)),
dispatchFetchEventEnd_(std::move(_dispatchFetchEventEnd)),
handleFetchEventStart_(std::move(_handleFetchEventStart)),
handleFetchEventEnd_(std::move(_handleFetchEventEnd)),
navigationStartTimeStamp_(std::move(_navigationStartTimeStamp)),
requestMethod_(std::move(_requestMethod)),
classOfService_(std::move(_classOfService)),
entityID_(std::move(_entityID)),
appCacheClientID_(std::move(_appCacheClientID)),
preflightArgs_(std::move(_preflightArgs)),
contentTypeHint_(std::move(_contentTypeHint)),
integrityMetadata_(std::move(_integrityMetadata)),
uploadStream_(std::move(_uploadStream)),
loadInfo_(std::move(_loadInfo)),
uploadStreamHasHeaders_(std::move(_uploadStreamHasHeaders)),
allowSTS_(std::move(_allowSTS)),
resumeAt_(std::move(_resumeAt)),
allowSpdy_(std::move(_allowSpdy)),
allowHttp3_(std::move(_allowHttp3)),
allowAltSvc_(std::move(_allowAltSvc)),
beConservative_(std::move(_beConservative)),
bypassProxy_(std::move(_bypassProxy)),
blockAuthPrompt_(std::move(_blockAuthPrompt)),
allowStaleCacheContent_(std::move(_allowStaleCacheContent)),
requestMode_(std::move(_requestMode)),
forceValidateCacheContent_(std::move(_forceValidateCacheContent)),
preferCacheLoadOverBypass_(std::move(_preferCacheLoadOverBypass)),
forceMainDocumentChannel_(std::move(_forceMainDocumentChannel)),
classicScriptHintCharset_(std::move(_classicScriptHintCharset)),
documentCharacterSet_(std::move(_documentCharacterSet)),
isUserAgentHeaderModified_(std::move(_isUserAgentHeaderModified)),
initiatorType_(std::move(_initiatorType)),
startPos_(std::move(_startPos)),
requestContextID_(std::move(_requestContextID)),
channelId_(std::move(_channelId)),
contentWindowId_(std::move(_contentWindowId)),
browserId_(std::move(_browserId)),
earlyHintPreloaderId_(std::move(_earlyHintPreloaderId)),
loadFlags_(std::move(_loadFlags)),
thirdPartyFlags_(std::move(_thirdPartyFlags)),
tlsFlags_(std::move(_tlsFlags)),
cacheKey_(std::move(_cacheKey)),
initialRwin_(std::move(_initialRwin)),
redirectMode_(std::move(_redirectMode)),
priority_(std::move(_priority)),
redirectionLimit_(std::move(_redirectionLimit))
{
}
RefPtr<nsIURI>&
uri()
{
return uri_;
}
nsIURI*
uri() const
{
return uri_;
}
RefPtr<nsIURI>&
original()
{
return original_;
}
nsIURI*
original() const
{
return original_;
}
RefPtr<nsIURI>&
doc()
{
return doc_;
}
nsIURI*
doc() const
{
return doc_;
}
RefPtr<nsIReferrerInfo>&
referrerInfo()
{
return referrerInfo_;
}
nsIReferrerInfo*
referrerInfo() const
{
return referrerInfo_;
}
RefPtr<nsIURI>&
apiRedirectTo()
{
return apiRedirectTo_;
}
nsIURI*
apiRedirectTo() const
{
return apiRedirectTo_;
}
RefPtr<nsIURI>&
topWindowURI()
{
return topWindowURI_;
}
nsIURI*
topWindowURI() const
{
return topWindowURI_;
}
RequestHeaderTuples&
requestHeaders()
{
return requestHeaders_;
}
const RequestHeaderTuples&
requestHeaders() const
{
return requestHeaders_;
}
nsTArray<PreferredAlternativeDataTypeParams>&
preferredAlternativeTypes()
{
return preferredAlternativeTypes_;
}
const nsTArray<PreferredAlternativeDataTypeParams>&
preferredAlternativeTypes() const
{
return preferredAlternativeTypes_;
}
TimeStamp&
launchServiceWorkerStart()
{
return launchServiceWorkerStart_;
}
const TimeStamp&
launchServiceWorkerStart() const
{
return launchServiceWorkerStart_;
}
TimeStamp&
launchServiceWorkerEnd()
{
return launchServiceWorkerEnd_;
}
const TimeStamp&
launchServiceWorkerEnd() const
{
return launchServiceWorkerEnd_;
}
TimeStamp&
dispatchFetchEventStart()
{
return dispatchFetchEventStart_;
}
const TimeStamp&
dispatchFetchEventStart() const
{
return dispatchFetchEventStart_;
}
TimeStamp&
dispatchFetchEventEnd()
{
return dispatchFetchEventEnd_;
}
const TimeStamp&
dispatchFetchEventEnd() const
{
return dispatchFetchEventEnd_;
}
TimeStamp&
handleFetchEventStart()
{
return handleFetchEventStart_;
}
const TimeStamp&
handleFetchEventStart() const
{
return handleFetchEventStart_;
}
TimeStamp&
handleFetchEventEnd()
{
return handleFetchEventEnd_;
}
const TimeStamp&
handleFetchEventEnd() const
{
return handleFetchEventEnd_;
}
TimeStamp&
navigationStartTimeStamp()
{
return navigationStartTimeStamp_;
}
const TimeStamp&
navigationStartTimeStamp() const
{
return navigationStartTimeStamp_;
}
uint64_t&
startPos()
{
return startPos_;
}
const uint64_t&
startPos() const
{
return startPos_;
}
uint64_t&
requestContextID()
{
return requestContextID_;
}
const uint64_t&
requestContextID() const
{
return requestContextID_;
}
uint64_t&
channelId()
{
return channelId_;
}
const uint64_t&
channelId() const
{
return channelId_;
}
uint64_t&
contentWindowId()
{
return contentWindowId_;
}
const uint64_t&
contentWindowId() const
{
return contentWindowId_;
}
uint64_t&
browserId()
{
return browserId_;
}
const uint64_t&
browserId() const
{
return browserId_;
}
uint64_t&
earlyHintPreloaderId()
{
return earlyHintPreloaderId_;
}
const uint64_t&
earlyHintPreloaderId() const
{
return earlyHintPreloaderId_;
}
nsCString&
requestMethod()
{
return requestMethod_;
}
const nsCString&
requestMethod() const
{
return requestMethod_;
}
ClassOfService&
classOfService()
{
return classOfService_;
}
const ClassOfService&
classOfService() const
{
return classOfService_;
}
nsCString&
entityID()
{
return entityID_;
}
const nsCString&
entityID() const
{
return entityID_;
}
nsCString&
appCacheClientID()
{
return appCacheClientID_;
}
const nsCString&
appCacheClientID() const
{
return appCacheClientID_;
}
mozilla::Maybe<CorsPreflightArgs>&
preflightArgs()
{
return preflightArgs_;
}
const mozilla::Maybe<CorsPreflightArgs>&
preflightArgs() const
{
return preflightArgs_;
}
nsCString&
contentTypeHint()
{
return contentTypeHint_;
}
const nsCString&
contentTypeHint() const
{
return contentTypeHint_;
}
nsString&
integrityMetadata()
{
return integrityMetadata_;
}
const nsString&
integrityMetadata() const
{
return integrityMetadata_;
}
mozilla::Maybe<IPCStream>&
uploadStream()
{
return uploadStream_;
}
const mozilla::Maybe<IPCStream>&
uploadStream() const
{
return uploadStream_;
}
LoadInfoArgs&
loadInfo()
{
return loadInfo_;
}
const LoadInfoArgs&
loadInfo() const
{
return loadInfo_;
}
uint32_t&
loadFlags()
{
return loadFlags_;
}
const uint32_t&
loadFlags() const
{
return loadFlags_;
}
uint32_t&
thirdPartyFlags()
{
return thirdPartyFlags_;
}
const uint32_t&
thirdPartyFlags() const
{
return thirdPartyFlags_;
}
uint32_t&
tlsFlags()
{
return tlsFlags_;
}
const uint32_t&
tlsFlags() const
{
return tlsFlags_;
}
uint32_t&
cacheKey()
{
return cacheKey_;
}
const uint32_t&
cacheKey() const
{
return cacheKey_;
}
uint32_t&
initialRwin()
{
return initialRwin_;
}
const uint32_t&
initialRwin() const
{
return initialRwin_;
}
uint32_t&
redirectMode()
{
return redirectMode_;
}
const uint32_t&
redirectMode() const
{
return redirectMode_;
}
int16_t&
priority()
{
return priority_;
}
const int16_t&
priority() const
{
return priority_;
}
bool&
uploadStreamHasHeaders()
{
return uploadStreamHasHeaders_;
}
const bool&
uploadStreamHasHeaders() const
{
return uploadStreamHasHeaders_;
}
bool&
allowSTS()
{
return allowSTS_;
}
const bool&
allowSTS() const
{
return allowSTS_;
}
bool&
resumeAt()
{
return resumeAt_;
}
const bool&
resumeAt() const
{
return resumeAt_;
}
bool&
allowSpdy()
{
return allowSpdy_;
}
const bool&
allowSpdy() const
{
return allowSpdy_;
}
bool&
allowHttp3()
{
return allowHttp3_;
}
const bool&
allowHttp3() const
{
return allowHttp3_;
}
bool&
allowAltSvc()
{
return allowAltSvc_;
}
const bool&
allowAltSvc() const
{
return allowAltSvc_;
}
bool&
beConservative()
{
return beConservative_;
}
const bool&
beConservative() const
{
return beConservative_;
}
bool&
bypassProxy()
{
return bypassProxy_;
}
const bool&
bypassProxy() const
{
return bypassProxy_;
}
bool&
blockAuthPrompt()
{
return blockAuthPrompt_;
}
const bool&
blockAuthPrompt() const
{
return blockAuthPrompt_;
}
bool&
allowStaleCacheContent()
{
return allowStaleCacheContent_;
}
const bool&
allowStaleCacheContent() const
{
return allowStaleCacheContent_;
}
RequestMode&
requestMode()
{
return requestMode_;
}
const RequestMode&
requestMode() const
{
return requestMode_;
}
bool&
forceValidateCacheContent()
{
return forceValidateCacheContent_;
}
const bool&
forceValidateCacheContent() const
{
return forceValidateCacheContent_;
}
bool&
preferCacheLoadOverBypass()
{
return preferCacheLoadOverBypass_;
}
const bool&
preferCacheLoadOverBypass() const
{
return preferCacheLoadOverBypass_;
}
bool&
forceMainDocumentChannel()
{
return forceMainDocumentChannel_;
}
const bool&
forceMainDocumentChannel() const
{
return forceMainDocumentChannel_;
}
uint8_t&
redirectionLimit()
{
return redirectionLimit_;
}
const uint8_t&
redirectionLimit() const
{
return redirectionLimit_;
}
nsString&
classicScriptHintCharset()
{
return classicScriptHintCharset_;
}
const nsString&
classicScriptHintCharset() const
{
return classicScriptHintCharset_;
}
nsString&
documentCharacterSet()
{
return documentCharacterSet_;
}
const nsString&
documentCharacterSet() const
{
return documentCharacterSet_;
}
bool&
isUserAgentHeaderModified()
{
return isUserAgentHeaderModified_;
}
const bool&
isUserAgentHeaderModified() const
{
return isUserAgentHeaderModified_;
}
nsString&
initiatorType()
{
return initiatorType_;
}
const nsString&
initiatorType() const
{
return initiatorType_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> uri_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> original_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> doc_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIReferrerInfo>> referrerInfo_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> apiRedirectTo_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> topWindowURI_;
::mozilla::ipc::IPDLStructMember<RequestHeaderTuples> requestHeaders_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<PreferredAlternativeDataTypeParams>> preferredAlternativeTypes_;
::mozilla::ipc::IPDLStructMember<TimeStamp> launchServiceWorkerStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> launchServiceWorkerEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> dispatchFetchEventStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> dispatchFetchEventEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> handleFetchEventStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> handleFetchEventEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> navigationStartTimeStamp_;
::mozilla::ipc::IPDLStructMember<nsCString> requestMethod_;
::mozilla::ipc::IPDLStructMember<ClassOfService> classOfService_;
::mozilla::ipc::IPDLStructMember<nsCString> entityID_;
::mozilla::ipc::IPDLStructMember<nsCString> appCacheClientID_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<CorsPreflightArgs>> preflightArgs_;
::mozilla::ipc::IPDLStructMember<nsCString> contentTypeHint_;
::mozilla::ipc::IPDLStructMember<nsString> integrityMetadata_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCStream>> uploadStream_;
::mozilla::ipc::IPDLStructMember<LoadInfoArgs> loadInfo_;
::mozilla::ipc::IPDLStructMember<bool> uploadStreamHasHeaders_;
::mozilla::ipc::IPDLStructMember<bool> allowSTS_;
::mozilla::ipc::IPDLStructMember<bool> resumeAt_;
::mozilla::ipc::IPDLStructMember<bool> allowSpdy_;
::mozilla::ipc::IPDLStructMember<bool> allowHttp3_;
::mozilla::ipc::IPDLStructMember<bool> allowAltSvc_;
::mozilla::ipc::IPDLStructMember<bool> beConservative_;
::mozilla::ipc::IPDLStructMember<bool> bypassProxy_;
::mozilla::ipc::IPDLStructMember<bool> blockAuthPrompt_;
::mozilla::ipc::IPDLStructMember<bool> allowStaleCacheContent_;
::mozilla::ipc::IPDLStructMember<RequestMode> requestMode_;
::mozilla::ipc::IPDLStructMember<bool> forceValidateCacheContent_;
::mozilla::ipc::IPDLStructMember<bool> preferCacheLoadOverBypass_;
::mozilla::ipc::IPDLStructMember<bool> forceMainDocumentChannel_;
::mozilla::ipc::IPDLStructMember<nsString> classicScriptHintCharset_;
::mozilla::ipc::IPDLStructMember<nsString> documentCharacterSet_;
::mozilla::ipc::IPDLStructMember<bool> isUserAgentHeaderModified_;
::mozilla::ipc::IPDLStructMember<nsString> initiatorType_;
::mozilla::ipc::IPDLStructMember<uint64_t> startPos_;
::mozilla::ipc::IPDLStructMember<uint64_t> requestContextID_;
::mozilla::ipc::IPDLStructMember<uint64_t> channelId_;
::mozilla::ipc::IPDLStructMember<uint64_t> contentWindowId_;
::mozilla::ipc::IPDLStructMember<uint64_t> browserId_;
::mozilla::ipc::IPDLStructMember<uint64_t> earlyHintPreloaderId_;
::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
::mozilla::ipc::IPDLStructMember<uint32_t> thirdPartyFlags_;
::mozilla::ipc::IPDLStructMember<uint32_t> tlsFlags_;
::mozilla::ipc::IPDLStructMember<uint32_t> cacheKey_;
::mozilla::ipc::IPDLStructMember<uint32_t> initialRwin_;
::mozilla::ipc::IPDLStructMember<uint32_t> redirectMode_;
::mozilla::ipc::IPDLStructMember<int16_t> priority_;
::mozilla::ipc::IPDLStructMember<uint8_t> redirectionLimit_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpChannelOpenArgs>
{
typedef ::mozilla::net::HttpChannelOpenArgs 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 HttpChannelConnectArgs|
//
namespace mozilla {
namespace net {
class HttpChannelConnectArgs final
{
private:
typedef ::uint32_t uint32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
HttpChannelConnectArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT HttpChannelConnectArgs(const uint32_t& _registrarId) :
registrarId_(_registrarId)
{
}
MOZ_IMPLICIT HttpChannelConnectArgs(uint32_t&& _registrarId) :
registrarId_(std::move(_registrarId))
{
}
uint32_t&
registrarId()
{
return registrarId_;
}
const uint32_t&
registrarId() const
{
return registrarId_;
}
private:
::mozilla::ipc::IPDLStructMember<uint32_t> registrarId_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpChannelConnectArgs>
{
typedef ::mozilla::net::HttpChannelConnectArgs 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 |union HttpChannelCreationArgs|
//
namespace mozilla {
namespace net {
class HttpChannelCreationArgs final
{
public:
enum Type {
T__None,
THttpChannelOpenArgs = 1,
THttpChannelConnectArgs,
T__Last = THttpChannelConnectArgs
};
private:
typedef ::mozilla::net::HttpChannelOpenArgs HttpChannelOpenArgs;
typedef ::mozilla::net::HttpChannelConnectArgs HttpChannelConnectArgs;
typedef HttpChannelOpenArgs HttpChannelOpenArgs__tdef;
typedef HttpChannelConnectArgs HttpChannelConnectArgs__tdef;
HttpChannelOpenArgs*
ptr_HttpChannelOpenArgs()
{
return (&(mVHttpChannelOpenArgs));
}
const HttpChannelOpenArgs*
constptr_HttpChannelOpenArgs() const
{
return (&(mVHttpChannelOpenArgs));
}
HttpChannelConnectArgs*
ptr_HttpChannelConnectArgs()
{
return (&(mVHttpChannelConnectArgs));
}
const HttpChannelConnectArgs*
constptr_HttpChannelConnectArgs() const
{
return (&(mVHttpChannelConnectArgs));
}
void
MaybeDestroy();
void
AssertSanity() const
{
MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
}
void
AssertSanity(Type aType) const
{
AssertSanity();
MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
}
public:
MOZ_IMPLICIT HttpChannelCreationArgs() :
mType(T__None)
{
}
MOZ_IMPLICIT HttpChannelCreationArgs(const HttpChannelOpenArgs& aOther);
MOZ_IMPLICIT HttpChannelCreationArgs(HttpChannelOpenArgs&& aOther);
MOZ_IMPLICIT HttpChannelCreationArgs(const HttpChannelConnectArgs& aOther);
MOZ_IMPLICIT HttpChannelCreationArgs(HttpChannelConnectArgs&& aOther);
MOZ_IMPLICIT HttpChannelCreationArgs(const HttpChannelCreationArgs& aOther);
MOZ_IMPLICIT HttpChannelCreationArgs(HttpChannelCreationArgs&& aOther);
~HttpChannelCreationArgs();
Type
type() const
{
return mType;
}
HttpChannelCreationArgs&
operator=(const HttpChannelOpenArgs& aRhs);
HttpChannelCreationArgs&
operator=(HttpChannelOpenArgs&& aRhs);
HttpChannelCreationArgs&
operator=(const HttpChannelConnectArgs& aRhs);
HttpChannelCreationArgs&
operator=(HttpChannelConnectArgs&& aRhs);
HttpChannelCreationArgs&
operator=(const HttpChannelCreationArgs& aRhs);
HttpChannelCreationArgs&
operator=(HttpChannelCreationArgs&& aRhs);
HttpChannelOpenArgs&
get_HttpChannelOpenArgs()
{
AssertSanity(THttpChannelOpenArgs);
return (*(ptr_HttpChannelOpenArgs()));
}
const HttpChannelOpenArgs&
get_HttpChannelOpenArgs() const
{
AssertSanity(THttpChannelOpenArgs);
return (*(constptr_HttpChannelOpenArgs()));
}
operator HttpChannelOpenArgs&()
{
return get_HttpChannelOpenArgs();
}
operator const HttpChannelOpenArgs&() const
{
return get_HttpChannelOpenArgs();
}
HttpChannelConnectArgs&
get_HttpChannelConnectArgs()
{
AssertSanity(THttpChannelConnectArgs);
return (*(ptr_HttpChannelConnectArgs()));
}
const HttpChannelConnectArgs&
get_HttpChannelConnectArgs() const
{
AssertSanity(THttpChannelConnectArgs);
return (*(constptr_HttpChannelConnectArgs()));
}
operator HttpChannelConnectArgs&()
{
return get_HttpChannelConnectArgs();
}
operator const HttpChannelConnectArgs&() const
{
return get_HttpChannelConnectArgs();
}
private:
union {
HttpChannelOpenArgs mVHttpChannelOpenArgs;
HttpChannelConnectArgs mVHttpChannelConnectArgs;
};
Type mType;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpChannelCreationArgs>
{
typedef ::mozilla::net::HttpChannelCreationArgs 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 ProxyInfoCloneArgs|
//
namespace mozilla {
namespace net {
class ProxyInfoCloneArgs final
{
private:
typedef ::nsCString nsCString;
typedef ::int32_t int32_t;
typedef ::uint32_t uint32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ProxyInfoCloneArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ProxyInfoCloneArgs(
const nsCString& _type,
const nsCString& _host,
const int32_t& _port,
const nsCString& _username,
const nsCString& _password,
const uint32_t& _flags,
const uint32_t& _timeout,
const uint32_t& _resolveFlags,
const nsCString& _proxyAuthorizationHeader,
const nsCString& _connectionIsolationKey) :
type_(_type),
host_(_host),
username_(_username),
password_(_password),
proxyAuthorizationHeader_(_proxyAuthorizationHeader),
connectionIsolationKey_(_connectionIsolationKey),
port_(_port),
flags_(_flags),
timeout_(_timeout),
resolveFlags_(_resolveFlags)
{
}
MOZ_IMPLICIT ProxyInfoCloneArgs(
nsCString&& _type,
nsCString&& _host,
int32_t&& _port,
nsCString&& _username,
nsCString&& _password,
uint32_t&& _flags,
uint32_t&& _timeout,
uint32_t&& _resolveFlags,
nsCString&& _proxyAuthorizationHeader,
nsCString&& _connectionIsolationKey) :
type_(std::move(_type)),
host_(std::move(_host)),
username_(std::move(_username)),
password_(std::move(_password)),
proxyAuthorizationHeader_(std::move(_proxyAuthorizationHeader)),
connectionIsolationKey_(std::move(_connectionIsolationKey)),
port_(std::move(_port)),
flags_(std::move(_flags)),
timeout_(std::move(_timeout)),
resolveFlags_(std::move(_resolveFlags))
{
}
nsCString&
type()
{
return type_;
}
const nsCString&
type() const
{
return type_;
}
nsCString&
host()
{
return host_;
}
const nsCString&
host() const
{
return host_;
}
int32_t&
port()
{
return port_;
}
const int32_t&
port() const
{
return port_;
}
nsCString&
username()
{
return username_;
}
const nsCString&
username() const
{
return username_;
}
nsCString&
password()
{
return password_;
}
const nsCString&
password() const
{
return password_;
}
uint32_t&
flags()
{
return flags_;
}
const uint32_t&
flags() const
{
return flags_;
}
uint32_t&
timeout()
{
return timeout_;
}
const uint32_t&
timeout() const
{
return timeout_;
}
uint32_t&
resolveFlags()
{
return resolveFlags_;
}
const uint32_t&
resolveFlags() const
{
return resolveFlags_;
}
nsCString&
proxyAuthorizationHeader()
{
return proxyAuthorizationHeader_;
}
const nsCString&
proxyAuthorizationHeader() const
{
return proxyAuthorizationHeader_;
}
nsCString&
connectionIsolationKey()
{
return connectionIsolationKey_;
}
const nsCString&
connectionIsolationKey() const
{
return connectionIsolationKey_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<nsCString> type_;
::mozilla::ipc::IPDLStructMember<nsCString> host_;
::mozilla::ipc::IPDLStructMember<nsCString> username_;
::mozilla::ipc::IPDLStructMember<nsCString> password_;
::mozilla::ipc::IPDLStructMember<nsCString> proxyAuthorizationHeader_;
::mozilla::ipc::IPDLStructMember<nsCString> connectionIsolationKey_;
::mozilla::ipc::IPDLStructMember<int32_t> port_;
::mozilla::ipc::IPDLStructMember<uint32_t> flags_;
::mozilla::ipc::IPDLStructMember<uint32_t> timeout_;
::mozilla::ipc::IPDLStructMember<uint32_t> resolveFlags_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::ProxyInfoCloneArgs>
{
typedef ::mozilla::net::ProxyInfoCloneArgs 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 HttpConnectionInfoCloneArgs|
//
namespace mozilla {
namespace net {
class HttpConnectionInfoCloneArgs final
{
private:
typedef ::nsCString nsCString;
typedef ::int32_t int32_t;
typedef ::mozilla::OriginAttributes OriginAttributes;
typedef ::uint32_t uint32_t;
typedef ::uint8_t uint8_t;
typedef ::uint64_t uint64_t;
typedef ::mozilla::net::ProxyInfoCloneArgs ProxyInfoCloneArgs;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
HttpConnectionInfoCloneArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT HttpConnectionInfoCloneArgs(
const nsCString& _host,
const int32_t& _port,
const nsCString& _npnToken,
const nsCString& _username,
const OriginAttributes& _originAttributes,
const bool& _endToEndSSL,
const nsCString& _routedHost,
const int32_t& _routedPort,
const bool& _anonymous,
const bool& _aPrivate,
const bool& _insecureScheme,
const bool& _noSpdy,
const bool& _beConservative,
const bool& _bypassProxy,
const bool& _anonymousAllowClientCert,
const bool& _fallbackConnection,
const uint32_t& _tlsFlags,
const bool& _isolated,
const bool& _isTrrServiceChannel,
const uint8_t& _trrMode,
const bool& _isIPv4Disabled,
const bool& _isIPv6Disabled,
const nsCString& _topWindowOrigin,
const bool& _isHttp3,
const bool& _webTransport,
const uint64_t& _webTransportId,
const bool& _hasIPHintAddress,
const nsCString& _echConfig,
const nsTArray<ProxyInfoCloneArgs>& _proxyInfo) :
host_(_host),
npnToken_(_npnToken),
username_(_username),
originAttributes_(_originAttributes),
endToEndSSL_(_endToEndSSL),
routedHost_(_routedHost),
anonymous_(_anonymous),
aPrivate_(_aPrivate),
insecureScheme_(_insecureScheme),
noSpdy_(_noSpdy),
beConservative_(_beConservative),
bypassProxy_(_bypassProxy),
anonymousAllowClientCert_(_anonymousAllowClientCert),
fallbackConnection_(_fallbackConnection),
isolated_(_isolated),
isTrrServiceChannel_(_isTrrServiceChannel),
isIPv4Disabled_(_isIPv4Disabled),
isIPv6Disabled_(_isIPv6Disabled),
topWindowOrigin_(_topWindowOrigin),
isHttp3_(_isHttp3),
webTransport_(_webTransport),
hasIPHintAddress_(_hasIPHintAddress),
echConfig_(_echConfig),
proxyInfo_(_proxyInfo),
webTransportId_(_webTransportId),
port_(_port),
routedPort_(_routedPort),
tlsFlags_(_tlsFlags),
trrMode_(_trrMode)
{
}
MOZ_IMPLICIT HttpConnectionInfoCloneArgs(
nsCString&& _host,
int32_t&& _port,
nsCString&& _npnToken,
nsCString&& _username,
OriginAttributes&& _originAttributes,
bool&& _endToEndSSL,
nsCString&& _routedHost,
int32_t&& _routedPort,
bool&& _anonymous,
bool&& _aPrivate,
bool&& _insecureScheme,
bool&& _noSpdy,
bool&& _beConservative,
bool&& _bypassProxy,
bool&& _anonymousAllowClientCert,
bool&& _fallbackConnection,
uint32_t&& _tlsFlags,
bool&& _isolated,
bool&& _isTrrServiceChannel,
uint8_t&& _trrMode,
bool&& _isIPv4Disabled,
bool&& _isIPv6Disabled,
nsCString&& _topWindowOrigin,
bool&& _isHttp3,
bool&& _webTransport,
uint64_t&& _webTransportId,
bool&& _hasIPHintAddress,
nsCString&& _echConfig,
nsTArray<ProxyInfoCloneArgs>&& _proxyInfo) :
host_(std::move(_host)),
npnToken_(std::move(_npnToken)),
username_(std::move(_username)),
originAttributes_(std::move(_originAttributes)),
endToEndSSL_(std::move(_endToEndSSL)),
routedHost_(std::move(_routedHost)),
anonymous_(std::move(_anonymous)),
aPrivate_(std::move(_aPrivate)),
insecureScheme_(std::move(_insecureScheme)),
noSpdy_(std::move(_noSpdy)),
beConservative_(std::move(_beConservative)),
bypassProxy_(std::move(_bypassProxy)),
anonymousAllowClientCert_(std::move(_anonymousAllowClientCert)),
fallbackConnection_(std::move(_fallbackConnection)),
isolated_(std::move(_isolated)),
isTrrServiceChannel_(std::move(_isTrrServiceChannel)),
isIPv4Disabled_(std::move(_isIPv4Disabled)),
isIPv6Disabled_(std::move(_isIPv6Disabled)),
topWindowOrigin_(std::move(_topWindowOrigin)),
isHttp3_(std::move(_isHttp3)),
webTransport_(std::move(_webTransport)),
hasIPHintAddress_(std::move(_hasIPHintAddress)),
echConfig_(std::move(_echConfig)),
proxyInfo_(std::move(_proxyInfo)),
webTransportId_(std::move(_webTransportId)),
port_(std::move(_port)),
routedPort_(std::move(_routedPort)),
tlsFlags_(std::move(_tlsFlags)),
trrMode_(std::move(_trrMode))
{
}
nsCString&
host()
{
return host_;
}
const nsCString&
host() const
{
return host_;
}
int32_t&
port()
{
return port_;
}
const int32_t&
port() const
{
return port_;
}
nsCString&
npnToken()
{
return npnToken_;
}
const nsCString&
npnToken() const
{
return npnToken_;
}
nsCString&
username()
{
return username_;
}
const nsCString&
username() const
{
return username_;
}
OriginAttributes&
originAttributes()
{
return originAttributes_;
}
const OriginAttributes&
originAttributes() const
{
return originAttributes_;
}
bool&
endToEndSSL()
{
return endToEndSSL_;
}
const bool&
endToEndSSL() const
{
return endToEndSSL_;
}
nsCString&
routedHost()
{
return routedHost_;
}
const nsCString&
routedHost() const
{
return routedHost_;
}
int32_t&
routedPort()
{
return routedPort_;
}
const int32_t&
routedPort() const
{
return routedPort_;
}
bool&
anonymous()
{
return anonymous_;
}
const bool&
anonymous() const
{
return anonymous_;
}
bool&
aPrivate()
{
return aPrivate_;
}
const bool&
aPrivate() const
{
return aPrivate_;
}
bool&
insecureScheme()
{
return insecureScheme_;
}
const bool&
insecureScheme() const
{
return insecureScheme_;
}
bool&
noSpdy()
{
return noSpdy_;
}
const bool&
noSpdy() const
{
return noSpdy_;
}
bool&
beConservative()
{
return beConservative_;
}
const bool&
beConservative() const
{
return beConservative_;
}
bool&
bypassProxy()
{
return bypassProxy_;
}
const bool&
bypassProxy() const
{
return bypassProxy_;
}
bool&
anonymousAllowClientCert()
{
return anonymousAllowClientCert_;
}
const bool&
anonymousAllowClientCert() const
{
return anonymousAllowClientCert_;
}
bool&
fallbackConnection()
{
return fallbackConnection_;
}
const bool&
fallbackConnection() const
{
return fallbackConnection_;
}
uint32_t&
tlsFlags()
{
return tlsFlags_;
}
const uint32_t&
tlsFlags() const
{
return tlsFlags_;
}
bool&
isolated()
{
return isolated_;
}
const bool&
isolated() const
{
return isolated_;
}
bool&
isTrrServiceChannel()
{
return isTrrServiceChannel_;
}
const bool&
isTrrServiceChannel() const
{
return isTrrServiceChannel_;
}
uint8_t&
trrMode()
{
return trrMode_;
}
const uint8_t&
trrMode() const
{
return trrMode_;
}
bool&
isIPv4Disabled()
{
return isIPv4Disabled_;
}
const bool&
isIPv4Disabled() const
{
return isIPv4Disabled_;
}
bool&
isIPv6Disabled()
{
return isIPv6Disabled_;
}
const bool&
isIPv6Disabled() const
{
return isIPv6Disabled_;
}
nsCString&
topWindowOrigin()
{
return topWindowOrigin_;
}
const nsCString&
topWindowOrigin() const
{
return topWindowOrigin_;
}
bool&
isHttp3()
{
return isHttp3_;
}
const bool&
isHttp3() const
{
return isHttp3_;
}
bool&
webTransport()
{
return webTransport_;
}
const bool&
webTransport() const
{
return webTransport_;
}
uint64_t&
webTransportId()
{
return webTransportId_;
}
const uint64_t&
webTransportId() const
{
return webTransportId_;
}
bool&
hasIPHintAddress()
{
return hasIPHintAddress_;
}
const bool&
hasIPHintAddress() const
{
return hasIPHintAddress_;
}
nsCString&
echConfig()
{
return echConfig_;
}
const nsCString&
echConfig() const
{
return echConfig_;
}
nsTArray<ProxyInfoCloneArgs>&
proxyInfo()
{
return proxyInfo_;
}
const nsTArray<ProxyInfoCloneArgs>&
proxyInfo() const
{
return proxyInfo_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<nsCString> host_;
::mozilla::ipc::IPDLStructMember<nsCString> npnToken_;
::mozilla::ipc::IPDLStructMember<nsCString> username_;
::mozilla::ipc::IPDLStructMember<OriginAttributes> originAttributes_;
::mozilla::ipc::IPDLStructMember<bool> endToEndSSL_;
::mozilla::ipc::IPDLStructMember<nsCString> routedHost_;
::mozilla::ipc::IPDLStructMember<bool> anonymous_;
::mozilla::ipc::IPDLStructMember<bool> aPrivate_;
::mozilla::ipc::IPDLStructMember<bool> insecureScheme_;
::mozilla::ipc::IPDLStructMember<bool> noSpdy_;
::mozilla::ipc::IPDLStructMember<bool> beConservative_;
::mozilla::ipc::IPDLStructMember<bool> bypassProxy_;
::mozilla::ipc::IPDLStructMember<bool> anonymousAllowClientCert_;
::mozilla::ipc::IPDLStructMember<bool> fallbackConnection_;
::mozilla::ipc::IPDLStructMember<bool> isolated_;
::mozilla::ipc::IPDLStructMember<bool> isTrrServiceChannel_;
::mozilla::ipc::IPDLStructMember<bool> isIPv4Disabled_;
::mozilla::ipc::IPDLStructMember<bool> isIPv6Disabled_;
::mozilla::ipc::IPDLStructMember<nsCString> topWindowOrigin_;
::mozilla::ipc::IPDLStructMember<bool> isHttp3_;
::mozilla::ipc::IPDLStructMember<bool> webTransport_;
::mozilla::ipc::IPDLStructMember<bool> hasIPHintAddress_;
::mozilla::ipc::IPDLStructMember<nsCString> echConfig_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<ProxyInfoCloneArgs>> proxyInfo_;
::mozilla::ipc::IPDLStructMember<uint64_t> webTransportId_;
::mozilla::ipc::IPDLStructMember<int32_t> port_;
::mozilla::ipc::IPDLStructMember<int32_t> routedPort_;
::mozilla::ipc::IPDLStructMember<uint32_t> tlsFlags_;
::mozilla::ipc::IPDLStructMember<uint8_t> trrMode_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpConnectionInfoCloneArgs>
{
typedef ::mozilla::net::HttpConnectionInfoCloneArgs 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 ConsoleReportCollected|
//
namespace mozilla {
namespace net {
class ConsoleReportCollected final
{
private:
typedef ::uint32_t uint32_t;
typedef ::nsCString nsCString;
typedef ::nsString nsString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ConsoleReportCollected() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ConsoleReportCollected(
const uint32_t& _errorFlags,
const nsCString& _category,
const uint32_t& _propertiesFile,
const nsCString& _sourceFileURI,
const uint32_t& _lineNumber,
const uint32_t& _columnNumber,
const nsCString& _messageName,
const nsTArray<nsString>& _stringParams) :
category_(_category),
sourceFileURI_(_sourceFileURI),
messageName_(_messageName),
stringParams_(_stringParams),
errorFlags_(_errorFlags),
propertiesFile_(_propertiesFile),
lineNumber_(_lineNumber),
columnNumber_(_columnNumber)
{
}
MOZ_IMPLICIT ConsoleReportCollected(
uint32_t&& _errorFlags,
nsCString&& _category,
uint32_t&& _propertiesFile,
nsCString&& _sourceFileURI,
uint32_t&& _lineNumber,
uint32_t&& _columnNumber,
nsCString&& _messageName,
nsTArray<nsString>&& _stringParams) :
category_(std::move(_category)),
sourceFileURI_(std::move(_sourceFileURI)),
messageName_(std::move(_messageName)),
stringParams_(std::move(_stringParams)),
errorFlags_(std::move(_errorFlags)),
propertiesFile_(std::move(_propertiesFile)),
lineNumber_(std::move(_lineNumber)),
columnNumber_(std::move(_columnNumber))
{
}
uint32_t&
errorFlags()
{
return errorFlags_;
}
const uint32_t&
errorFlags() const
{
return errorFlags_;
}
nsCString&
category()
{
return category_;
}
const nsCString&
category() const
{
return category_;
}
uint32_t&
propertiesFile()
{
return propertiesFile_;
}
const uint32_t&
propertiesFile() const
{
return propertiesFile_;
}
nsCString&
sourceFileURI()
{
return sourceFileURI_;
}
const nsCString&
sourceFileURI() const
{
return sourceFileURI_;
}
uint32_t&
lineNumber()
{
return lineNumber_;
}
const uint32_t&
lineNumber() const
{
return lineNumber_;
}
uint32_t&
columnNumber()
{
return columnNumber_;
}
const uint32_t&
columnNumber() const
{
return columnNumber_;
}
nsCString&
messageName()
{
return messageName_;
}
const nsCString&
messageName() const
{
return messageName_;
}
nsTArray<nsString>&
stringParams()
{
return stringParams_;
}
const nsTArray<nsString>&
stringParams() const
{
return stringParams_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<nsCString> category_;
::mozilla::ipc::IPDLStructMember<nsCString> sourceFileURI_;
::mozilla::ipc::IPDLStructMember<nsCString> messageName_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<nsString>> stringParams_;
::mozilla::ipc::IPDLStructMember<uint32_t> errorFlags_;
::mozilla::ipc::IPDLStructMember<uint32_t> propertiesFile_;
::mozilla::ipc::IPDLStructMember<uint32_t> lineNumber_;
::mozilla::ipc::IPDLStructMember<uint32_t> columnNumber_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::ConsoleReportCollected>
{
typedef ::mozilla::net::ConsoleReportCollected 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 CookieStruct|
//
namespace mozilla {
namespace net {
class CookieStruct final
{
private:
typedef ::nsCString nsCString;
typedef ::int64_t int64_t;
typedef ::int32_t int32_t;
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
CookieStruct() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CookieStruct(
const nsCString& _name,
const nsCString& _value,
const nsCString& _host,
const nsCString& _path,
const int64_t& _expiry,
const int64_t& _lastAccessed,
const int64_t& _creationTime,
const bool& _isHttpOnly,
const bool& _isSession,
const bool& _isSecure,
const bool& _isPartitioned,
const int32_t& _sameSite,
const int32_t& _rawSameSite,
const uint8_t& _schemeMap) :
name_(_name),
value_(_value),
host_(_host),
path_(_path),
isHttpOnly_(_isHttpOnly),
isSession_(_isSession),
isSecure_(_isSecure),
isPartitioned_(_isPartitioned),
expiry_(_expiry),
lastAccessed_(_lastAccessed),
creationTime_(_creationTime),
sameSite_(_sameSite),
rawSameSite_(_rawSameSite),
schemeMap_(_schemeMap)
{
}
MOZ_IMPLICIT CookieStruct(
nsCString&& _name,
nsCString&& _value,
nsCString&& _host,
nsCString&& _path,
int64_t&& _expiry,
int64_t&& _lastAccessed,
int64_t&& _creationTime,
bool&& _isHttpOnly,
bool&& _isSession,
bool&& _isSecure,
bool&& _isPartitioned,
int32_t&& _sameSite,
int32_t&& _rawSameSite,
uint8_t&& _schemeMap) :
name_(std::move(_name)),
value_(std::move(_value)),
host_(std::move(_host)),
path_(std::move(_path)),
isHttpOnly_(std::move(_isHttpOnly)),
isSession_(std::move(_isSession)),
isSecure_(std::move(_isSecure)),
isPartitioned_(std::move(_isPartitioned)),
expiry_(std::move(_expiry)),
lastAccessed_(std::move(_lastAccessed)),
creationTime_(std::move(_creationTime)),
sameSite_(std::move(_sameSite)),
rawSameSite_(std::move(_rawSameSite)),
schemeMap_(std::move(_schemeMap))
{
}
nsCString&
name()
{
return name_;
}
const nsCString&
name() const
{
return name_;
}
nsCString&
value()
{
return value_;
}
const nsCString&
value() const
{
return value_;
}
nsCString&
host()
{
return host_;
}
const nsCString&
host() const
{
return host_;
}
nsCString&
path()
{
return path_;
}
const nsCString&
path() const
{
return path_;
}
int64_t&
expiry()
{
return expiry_;
}
const int64_t&
expiry() const
{
return expiry_;
}
int64_t&
lastAccessed()
{
return lastAccessed_;
}
const int64_t&
lastAccessed() const
{
return lastAccessed_;
}
int64_t&
creationTime()
{
return creationTime_;
}
const int64_t&
creationTime() const
{
return creationTime_;
}
bool&
isHttpOnly()
{
return isHttpOnly_;
}
const bool&
isHttpOnly() const
{
return isHttpOnly_;
}
bool&
isSession()
{
return isSession_;
}
const bool&
isSession() const
{
return isSession_;
}
bool&
isSecure()
{
return isSecure_;
}
const bool&
isSecure() const
{
return isSecure_;
}
bool&
isPartitioned()
{
return isPartitioned_;
}
const bool&
isPartitioned() const
{
return isPartitioned_;
}
int32_t&
sameSite()
{
return sameSite_;
}
const int32_t&
sameSite() const
{
return sameSite_;
}
int32_t&
rawSameSite()
{
return rawSameSite_;
}
const int32_t&
rawSameSite() const
{
return rawSameSite_;
}
uint8_t&
schemeMap()
{
return schemeMap_;
}
const uint8_t&
schemeMap() const
{
return schemeMap_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<nsCString> name_;
::mozilla::ipc::IPDLStructMember<nsCString> value_;
::mozilla::ipc::IPDLStructMember<nsCString> host_;
::mozilla::ipc::IPDLStructMember<nsCString> path_;
::mozilla::ipc::IPDLStructMember<bool> isHttpOnly_;
::mozilla::ipc::IPDLStructMember<bool> isSession_;
::mozilla::ipc::IPDLStructMember<bool> isSecure_;
::mozilla::ipc::IPDLStructMember<bool> isPartitioned_;
::mozilla::ipc::IPDLStructMember<int64_t> expiry_;
::mozilla::ipc::IPDLStructMember<int64_t> lastAccessed_;
::mozilla::ipc::IPDLStructMember<int64_t> creationTime_;
::mozilla::ipc::IPDLStructMember<int32_t> sameSite_;
::mozilla::ipc::IPDLStructMember<int32_t> rawSameSite_;
::mozilla::ipc::IPDLStructMember<uint8_t> schemeMap_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::CookieStruct>
{
typedef ::mozilla::net::CookieStruct 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 CookieStructTable|
//
namespace mozilla {
namespace net {
class CookieStructTable final
{
private:
typedef ::mozilla::OriginAttributes OriginAttributes;
typedef ::mozilla::net::CookieStruct CookieStruct;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
CookieStructTable() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CookieStructTable(
const OriginAttributes& _attrs,
const nsTArray<CookieStruct>& _cookies) :
attrs_(_attrs),
cookies_(_cookies)
{
}
MOZ_IMPLICIT CookieStructTable(
OriginAttributes&& _attrs,
nsTArray<CookieStruct>&& _cookies) :
attrs_(std::move(_attrs)),
cookies_(std::move(_cookies))
{
}
OriginAttributes&
attrs()
{
return attrs_;
}
const OriginAttributes&
attrs() const
{
return attrs_;
}
nsTArray<CookieStruct>&
cookies()
{
return cookies_;
}
const nsTArray<CookieStruct>&
cookies() const
{
return cookies_;
}
private:
::mozilla::ipc::IPDLStructMember<OriginAttributes> attrs_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<CookieStruct>> cookies_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::CookieStructTable>
{
typedef ::mozilla::net::CookieStructTable 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 DocumentCreationArgs|
//
namespace mozilla {
namespace net {
class DocumentCreationArgs final
{
private:
typedef ::uint32_t uint32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
DocumentCreationArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT DocumentCreationArgs(
const uint32_t& _loadFlags,
const bool& _uriModified,
const bool& _isEmbeddingBlockedError) :
uriModified_(_uriModified),
isEmbeddingBlockedError_(_isEmbeddingBlockedError),
loadFlags_(_loadFlags)
{
}
MOZ_IMPLICIT DocumentCreationArgs(
uint32_t&& _loadFlags,
bool&& _uriModified,
bool&& _isEmbeddingBlockedError) :
uriModified_(std::move(_uriModified)),
isEmbeddingBlockedError_(std::move(_isEmbeddingBlockedError)),
loadFlags_(std::move(_loadFlags))
{
}
uint32_t&
loadFlags()
{
return loadFlags_;
}
const uint32_t&
loadFlags() const
{
return loadFlags_;
}
bool&
uriModified()
{
return uriModified_;
}
const bool&
uriModified() const
{
return uriModified_;
}
bool&
isEmbeddingBlockedError()
{
return isEmbeddingBlockedError_;
}
const bool&
isEmbeddingBlockedError() const
{
return isEmbeddingBlockedError_;
}
private:
::mozilla::ipc::IPDLStructMember<bool> uriModified_;
::mozilla::ipc::IPDLStructMember<bool> isEmbeddingBlockedError_;
::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::DocumentCreationArgs>
{
typedef ::mozilla::net::DocumentCreationArgs 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 ObjectCreationArgs|
//
namespace mozilla {
namespace net {
class ObjectCreationArgs final
{
private:
typedef ::uint32_t uint32_t;
typedef ::uint64_t uint64_t;
typedef ::nsContentPolicyType nsContentPolicyType;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ObjectCreationArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ObjectCreationArgs(
const uint32_t& _loadFlags,
const uint64_t& _embedderInnerWindowId,
const nsContentPolicyType& _contentPolicyType,
const bool& _isUrgentStart) :
contentPolicyType_(_contentPolicyType),
isUrgentStart_(_isUrgentStart),
embedderInnerWindowId_(_embedderInnerWindowId),
loadFlags_(_loadFlags)
{
}
MOZ_IMPLICIT ObjectCreationArgs(
uint32_t&& _loadFlags,
uint64_t&& _embedderInnerWindowId,
nsContentPolicyType&& _contentPolicyType,
bool&& _isUrgentStart) :
contentPolicyType_(std::move(_contentPolicyType)),
isUrgentStart_(std::move(_isUrgentStart)),
embedderInnerWindowId_(std::move(_embedderInnerWindowId)),
loadFlags_(std::move(_loadFlags))
{
}
uint32_t&
loadFlags()
{
return loadFlags_;
}
const uint32_t&
loadFlags() const
{
return loadFlags_;
}
uint64_t&
embedderInnerWindowId()
{
return embedderInnerWindowId_;
}
const uint64_t&
embedderInnerWindowId() const
{
return embedderInnerWindowId_;
}
nsContentPolicyType&
contentPolicyType()
{
return contentPolicyType_;
}
const nsContentPolicyType&
contentPolicyType() const
{
return contentPolicyType_;
}
bool&
isUrgentStart()
{
return isUrgentStart_;
}
const bool&
isUrgentStart() const
{
return isUrgentStart_;
}
private:
::mozilla::ipc::IPDLStructMember<nsContentPolicyType> contentPolicyType_;
::mozilla::ipc::IPDLStructMember<bool> isUrgentStart_;
::mozilla::ipc::IPDLStructMember<uint64_t> embedderInnerWindowId_;
::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::ObjectCreationArgs>
{
typedef ::mozilla::net::ObjectCreationArgs 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 |union DocumentChannelElementCreationArgs|
//
namespace mozilla {
namespace net {
class DocumentChannelElementCreationArgs final
{
public:
enum Type {
T__None,
TDocumentCreationArgs = 1,
TObjectCreationArgs,
T__Last = TObjectCreationArgs
};
private:
typedef ::mozilla::net::DocumentCreationArgs DocumentCreationArgs;
typedef ::mozilla::net::ObjectCreationArgs ObjectCreationArgs;
typedef DocumentCreationArgs DocumentCreationArgs__tdef;
typedef ObjectCreationArgs ObjectCreationArgs__tdef;
DocumentCreationArgs*
ptr_DocumentCreationArgs()
{
return (&(mVDocumentCreationArgs));
}
const DocumentCreationArgs*
constptr_DocumentCreationArgs() const
{
return (&(mVDocumentCreationArgs));
}
ObjectCreationArgs*
ptr_ObjectCreationArgs()
{
return (&(mVObjectCreationArgs));
}
const ObjectCreationArgs*
constptr_ObjectCreationArgs() const
{
return (&(mVObjectCreationArgs));
}
void
MaybeDestroy();
void
AssertSanity() const
{
MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
}
void
AssertSanity(Type aType) const
{
AssertSanity();
MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
}
public:
MOZ_IMPLICIT DocumentChannelElementCreationArgs() :
mType(T__None)
{
}
MOZ_IMPLICIT DocumentChannelElementCreationArgs(const DocumentCreationArgs& aOther);
MOZ_IMPLICIT DocumentChannelElementCreationArgs(DocumentCreationArgs&& aOther);
MOZ_IMPLICIT DocumentChannelElementCreationArgs(const ObjectCreationArgs& aOther);
MOZ_IMPLICIT DocumentChannelElementCreationArgs(ObjectCreationArgs&& aOther);
MOZ_IMPLICIT DocumentChannelElementCreationArgs(const DocumentChannelElementCreationArgs& aOther);
MOZ_IMPLICIT DocumentChannelElementCreationArgs(DocumentChannelElementCreationArgs&& aOther);
~DocumentChannelElementCreationArgs();
Type
type() const
{
return mType;
}
DocumentChannelElementCreationArgs&
operator=(const DocumentCreationArgs& aRhs);
DocumentChannelElementCreationArgs&
operator=(DocumentCreationArgs&& aRhs);
DocumentChannelElementCreationArgs&
operator=(const ObjectCreationArgs& aRhs);
DocumentChannelElementCreationArgs&
operator=(ObjectCreationArgs&& aRhs);
DocumentChannelElementCreationArgs&
operator=(const DocumentChannelElementCreationArgs& aRhs);
DocumentChannelElementCreationArgs&
operator=(DocumentChannelElementCreationArgs&& aRhs);
DocumentCreationArgs&
get_DocumentCreationArgs()
{
AssertSanity(TDocumentCreationArgs);
return (*(ptr_DocumentCreationArgs()));
}
const DocumentCreationArgs&
get_DocumentCreationArgs() const
{
AssertSanity(TDocumentCreationArgs);
return (*(constptr_DocumentCreationArgs()));
}
operator DocumentCreationArgs&()
{
return get_DocumentCreationArgs();
}
operator const DocumentCreationArgs&() const
{
return get_DocumentCreationArgs();
}
ObjectCreationArgs&
get_ObjectCreationArgs()
{
AssertSanity(TObjectCreationArgs);
return (*(ptr_ObjectCreationArgs()));
}
const ObjectCreationArgs&
get_ObjectCreationArgs() const
{
AssertSanity(TObjectCreationArgs);
return (*(constptr_ObjectCreationArgs()));
}
operator ObjectCreationArgs&()
{
return get_ObjectCreationArgs();
}
operator const ObjectCreationArgs&() const
{
return get_ObjectCreationArgs();
}
private:
union {
DocumentCreationArgs mVDocumentCreationArgs;
ObjectCreationArgs mVObjectCreationArgs;
};
Type mType;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::DocumentChannelElementCreationArgs>
{
typedef ::mozilla::net::DocumentChannelElementCreationArgs 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 DocumentChannelCreationArgs|
//
namespace mozilla {
namespace net {
class DocumentChannelCreationArgs final
{
private:
typedef ::nsDocShellLoadState nsDocShellLoadState;
typedef ::mozilla::TimeStamp TimeStamp;
typedef ::uint64_t uint64_t;
typedef ::uint32_t uint32_t;
typedef ::nsDOMNavigationTiming nsDOMNavigationTiming;
typedef ::mozilla::dom::IPCClientInfo IPCClientInfo;
typedef ::mozilla::net::DocumentChannelElementCreationArgs DocumentChannelElementCreationArgs;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
DocumentChannelCreationArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT DocumentChannelCreationArgs(
mozilla::NotNull<nsDocShellLoadState*> _loadState,
const TimeStamp& _asyncOpenTime,
const uint64_t& _channelId,
const uint32_t& _cacheKey,
nsDOMNavigationTiming* _timing,
const mozilla::Maybe<IPCClientInfo>& _initialClientInfo,
const DocumentChannelElementCreationArgs& _elementCreationArgs,
const uint64_t& _parentInitiatedNavigationEpoch) :
loadState_(_loadState),
asyncOpenTime_(_asyncOpenTime),
timing_(_timing),
initialClientInfo_(_initialClientInfo),
elementCreationArgs_(_elementCreationArgs),
channelId_(_channelId),
parentInitiatedNavigationEpoch_(_parentInitiatedNavigationEpoch),
cacheKey_(_cacheKey)
{
}
MOZ_IMPLICIT DocumentChannelCreationArgs(
mozilla::NotNull<RefPtr<nsDocShellLoadState>>&& _loadState,
TimeStamp&& _asyncOpenTime,
uint64_t&& _channelId,
uint32_t&& _cacheKey,
RefPtr<nsDOMNavigationTiming>&& _timing,
mozilla::Maybe<IPCClientInfo>&& _initialClientInfo,
DocumentChannelElementCreationArgs&& _elementCreationArgs,
uint64_t&& _parentInitiatedNavigationEpoch) :
loadState_(std::move(_loadState)),
asyncOpenTime_(std::move(_asyncOpenTime)),
timing_(std::move(_timing)),
initialClientInfo_(std::move(_initialClientInfo)),
elementCreationArgs_(std::move(_elementCreationArgs)),
channelId_(std::move(_channelId)),
parentInitiatedNavigationEpoch_(std::move(_parentInitiatedNavigationEpoch)),
cacheKey_(std::move(_cacheKey))
{
}
mozilla::NotNull<RefPtr<nsDocShellLoadState>>&
loadState()
{
return loadState_;
}
mozilla::NotNull<nsDocShellLoadState*>
loadState() const
{
return loadState_;
}
TimeStamp&
asyncOpenTime()
{
return asyncOpenTime_;
}
const TimeStamp&
asyncOpenTime() const
{
return asyncOpenTime_;
}
uint64_t&
channelId()
{
return channelId_;
}
const uint64_t&
channelId() const
{
return channelId_;
}
uint32_t&
cacheKey()
{
return cacheKey_;
}
const uint32_t&
cacheKey() const
{
return cacheKey_;
}
RefPtr<nsDOMNavigationTiming>&
timing()
{
return timing_;
}
nsDOMNavigationTiming*
timing() const
{
return timing_;
}
mozilla::Maybe<IPCClientInfo>&
initialClientInfo()
{
return initialClientInfo_;
}
const mozilla::Maybe<IPCClientInfo>&
initialClientInfo() const
{
return initialClientInfo_;
}
DocumentChannelElementCreationArgs&
elementCreationArgs()
{
return elementCreationArgs_;
}
const DocumentChannelElementCreationArgs&
elementCreationArgs() const
{
return elementCreationArgs_;
}
uint64_t&
parentInitiatedNavigationEpoch()
{
return parentInitiatedNavigationEpoch_;
}
const uint64_t&
parentInitiatedNavigationEpoch() const
{
return parentInitiatedNavigationEpoch_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<mozilla::NotNull<RefPtr<nsDocShellLoadState>>> loadState_;
::mozilla::ipc::IPDLStructMember<TimeStamp> asyncOpenTime_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsDOMNavigationTiming>> timing_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> initialClientInfo_;
::mozilla::ipc::IPDLStructMember<DocumentChannelElementCreationArgs> elementCreationArgs_;
::mozilla::ipc::IPDLStructMember<uint64_t> channelId_;
::mozilla::ipc::IPDLStructMember<uint64_t> parentInitiatedNavigationEpoch_;
::mozilla::ipc::IPDLStructMember<uint32_t> cacheKey_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::DocumentChannelCreationArgs>
{
typedef ::mozilla::net::DocumentChannelCreationArgs 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 EarlyHintConnectArgs|
//
namespace mozilla {
namespace net {
class EarlyHintConnectArgs final
{
private:
typedef ::mozilla::net::LinkHeader LinkHeader;
typedef ::uint64_t uint64_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
EarlyHintConnectArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT EarlyHintConnectArgs(
const LinkHeader& _link,
const uint64_t& _earlyHintPreloaderId) :
link_(_link),
earlyHintPreloaderId_(_earlyHintPreloaderId)
{
}
MOZ_IMPLICIT EarlyHintConnectArgs(
LinkHeader&& _link,
uint64_t&& _earlyHintPreloaderId) :
link_(std::move(_link)),
earlyHintPreloaderId_(std::move(_earlyHintPreloaderId))
{
}
LinkHeader&
link()
{
return link_;
}
const LinkHeader&
link() const
{
return link_;
}
uint64_t&
earlyHintPreloaderId()
{
return earlyHintPreloaderId_;
}
const uint64_t&
earlyHintPreloaderId() const
{
return earlyHintPreloaderId_;
}
private:
::mozilla::ipc::IPDLStructMember<LinkHeader> link_;
::mozilla::ipc::IPDLStructMember<uint64_t> earlyHintPreloaderId_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::EarlyHintConnectArgs>
{
typedef ::mozilla::net::EarlyHintConnectArgs 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 RedirectToRealChannelArgs|
//
namespace mozilla {
namespace net {
class RedirectToRealChannelArgs final
{
private:
typedef ::uint32_t uint32_t;
typedef ::nsIURI nsIURI;
typedef ::mozilla::dom::ReplacementChannelConfigInit ReplacementChannelConfigInit;
typedef ::mozilla::net::LoadInfoArgs LoadInfoArgs;
typedef ::uint64_t uint64_t;
typedef ::nsString nsString;
typedef ::nsIPropertyBag2 nsIPropertyBag2;
typedef ::nsDOMNavigationTiming nsDOMNavigationTiming;
typedef ::mozilla::dom::LoadingSessionHistoryInfo LoadingSessionHistoryInfo;
typedef ::nsCString nsCString;
typedef ::mozilla::net::EarlyHintConnectArgs EarlyHintConnectArgs;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
RedirectToRealChannelArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT RedirectToRealChannelArgs(
const uint32_t& _registrarId,
nsIURI* _uri,
const uint32_t& _newLoadFlags,
const mozilla::Maybe<ReplacementChannelConfigInit>& _init,
const LoadInfoArgs& _loadInfo,
const uint64_t& _channelId,
nsIURI* _originalURI,
const uint32_t& _redirectMode,
const uint32_t& _redirectFlags,
const mozilla::Maybe<uint32_t>& _contentDisposition,
const mozilla::Maybe<nsString>& _contentDispositionFilename,
nsIPropertyBag2* _properties,
const uint32_t& _loadStateExternalLoadFlags,
const uint32_t& _loadStateInternalLoadFlags,
const uint32_t& _loadStateLoadType,
nsDOMNavigationTiming* _timing,
const nsString& _srcdocData,
nsIURI* _baseUri,
const mozilla::Maybe<LoadingSessionHistoryInfo>& _loadingSessionHistoryInfo,
const uint64_t& _loadIdentifier,
const mozilla::Maybe<nsCString>& _originalUriString,
const nsTArray<EarlyHintConnectArgs>& _earlyHints,
const uint32_t& _earlyHintLinkType) :
uri_(_uri),
init_(_init),
loadInfo_(_loadInfo),
originalURI_(_originalURI),
contentDisposition_(_contentDisposition),
contentDispositionFilename_(_contentDispositionFilename),
properties_(_properties),
timing_(_timing),
srcdocData_(_srcdocData),
baseUri_(_baseUri),
loadingSessionHistoryInfo_(_loadingSessionHistoryInfo),
originalUriString_(_originalUriString),
earlyHints_(_earlyHints),
channelId_(_channelId),
loadIdentifier_(_loadIdentifier),
registrarId_(_registrarId),
newLoadFlags_(_newLoadFlags),
redirectMode_(_redirectMode),
redirectFlags_(_redirectFlags),
loadStateExternalLoadFlags_(_loadStateExternalLoadFlags),
loadStateInternalLoadFlags_(_loadStateInternalLoadFlags),
loadStateLoadType_(_loadStateLoadType),
earlyHintLinkType_(_earlyHintLinkType)
{
}
MOZ_IMPLICIT RedirectToRealChannelArgs(
uint32_t&& _registrarId,
RefPtr<nsIURI>&& _uri,
uint32_t&& _newLoadFlags,
mozilla::Maybe<ReplacementChannelConfigInit>&& _init,
LoadInfoArgs&& _loadInfo,
uint64_t&& _channelId,
RefPtr<nsIURI>&& _originalURI,
uint32_t&& _redirectMode,
uint32_t&& _redirectFlags,
mozilla::Maybe<uint32_t>&& _contentDisposition,
mozilla::Maybe<nsString>&& _contentDispositionFilename,
RefPtr<nsIPropertyBag2>&& _properties,
uint32_t&& _loadStateExternalLoadFlags,
uint32_t&& _loadStateInternalLoadFlags,
uint32_t&& _loadStateLoadType,
RefPtr<nsDOMNavigationTiming>&& _timing,
nsString&& _srcdocData,
RefPtr<nsIURI>&& _baseUri,
mozilla::Maybe<LoadingSessionHistoryInfo>&& _loadingSessionHistoryInfo,
uint64_t&& _loadIdentifier,
mozilla::Maybe<nsCString>&& _originalUriString,
nsTArray<EarlyHintConnectArgs>&& _earlyHints,
uint32_t&& _earlyHintLinkType) :
uri_(std::move(_uri)),
init_(std::move(_init)),
loadInfo_(std::move(_loadInfo)),
originalURI_(std::move(_originalURI)),
contentDisposition_(std::move(_contentDisposition)),
contentDispositionFilename_(std::move(_contentDispositionFilename)),
properties_(std::move(_properties)),
timing_(std::move(_timing)),
srcdocData_(std::move(_srcdocData)),
baseUri_(std::move(_baseUri)),
loadingSessionHistoryInfo_(std::move(_loadingSessionHistoryInfo)),
originalUriString_(std::move(_originalUriString)),
earlyHints_(std::move(_earlyHints)),
channelId_(std::move(_channelId)),
loadIdentifier_(std::move(_loadIdentifier)),
registrarId_(std::move(_registrarId)),
newLoadFlags_(std::move(_newLoadFlags)),
redirectMode_(std::move(_redirectMode)),
redirectFlags_(std::move(_redirectFlags)),
loadStateExternalLoadFlags_(std::move(_loadStateExternalLoadFlags)),
loadStateInternalLoadFlags_(std::move(_loadStateInternalLoadFlags)),
loadStateLoadType_(std::move(_loadStateLoadType)),
earlyHintLinkType_(std::move(_earlyHintLinkType))
{
}
uint32_t&
registrarId()
{
return registrarId_;
}
const uint32_t&
registrarId() const
{
return registrarId_;
}
RefPtr<nsIURI>&
uri()
{
return uri_;
}
nsIURI*
uri() const
{
return uri_;
}
uint32_t&
newLoadFlags()
{
return newLoadFlags_;
}
const uint32_t&
newLoadFlags() const
{
return newLoadFlags_;
}
mozilla::Maybe<ReplacementChannelConfigInit>&
init()
{
return init_;
}
const mozilla::Maybe<ReplacementChannelConfigInit>&
init() const
{
return init_;
}
LoadInfoArgs&
loadInfo()
{
return loadInfo_;
}
const LoadInfoArgs&
loadInfo() const
{
return loadInfo_;
}
uint64_t&
channelId()
{
return channelId_;
}
const uint64_t&
channelId() const
{
return channelId_;
}
RefPtr<nsIURI>&
originalURI()
{
return originalURI_;
}
nsIURI*
originalURI() const
{
return originalURI_;
}
uint32_t&
redirectMode()
{
return redirectMode_;
}
const uint32_t&
redirectMode() const
{
return redirectMode_;
}
uint32_t&
redirectFlags()
{
return redirectFlags_;
}
const uint32_t&
redirectFlags() const
{
return redirectFlags_;
}
mozilla::Maybe<uint32_t>&
contentDisposition()
{
return contentDisposition_;
}
const mozilla::Maybe<uint32_t>&
contentDisposition() const
{
return contentDisposition_;
}
mozilla::Maybe<nsString>&
contentDispositionFilename()
{
return contentDispositionFilename_;
}
const mozilla::Maybe<nsString>&
contentDispositionFilename() const
{
return contentDispositionFilename_;
}
RefPtr<nsIPropertyBag2>&
properties()
{
return properties_;
}
nsIPropertyBag2*
properties() const
{
return properties_;
}
uint32_t&
loadStateExternalLoadFlags()
{
return loadStateExternalLoadFlags_;
}
const uint32_t&
loadStateExternalLoadFlags() const
{
return loadStateExternalLoadFlags_;
}
uint32_t&
loadStateInternalLoadFlags()
{
return loadStateInternalLoadFlags_;
}
const uint32_t&
loadStateInternalLoadFlags() const
{
return loadStateInternalLoadFlags_;
}
uint32_t&
loadStateLoadType()
{
return loadStateLoadType_;
}
const uint32_t&
loadStateLoadType() const
{
return loadStateLoadType_;
}
RefPtr<nsDOMNavigationTiming>&
timing()
{
return timing_;
}
nsDOMNavigationTiming*
timing() const
{
return timing_;
}
nsString&
srcdocData()
{
return srcdocData_;
}
const nsString&
srcdocData() const
{
return srcdocData_;
}
RefPtr<nsIURI>&
baseUri()
{
return baseUri_;
}
nsIURI*
baseUri() const
{
return baseUri_;
}
mozilla::Maybe<LoadingSessionHistoryInfo>&
loadingSessionHistoryInfo()
{
return loadingSessionHistoryInfo_;
}
const mozilla::Maybe<LoadingSessionHistoryInfo>&
loadingSessionHistoryInfo() const
{
return loadingSessionHistoryInfo_;
}
uint64_t&
loadIdentifier()
{
return loadIdentifier_;
}
const uint64_t&
loadIdentifier() const
{
return loadIdentifier_;
}
mozilla::Maybe<nsCString>&
originalUriString()
{
return originalUriString_;
}
const mozilla::Maybe<nsCString>&
originalUriString() const
{
return originalUriString_;
}
nsTArray<EarlyHintConnectArgs>&
earlyHints()
{
return earlyHints_;
}
const nsTArray<EarlyHintConnectArgs>&
earlyHints() const
{
return earlyHints_;
}
uint32_t&
earlyHintLinkType()
{
return earlyHintLinkType_;
}
const uint32_t&
earlyHintLinkType() const
{
return earlyHintLinkType_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> uri_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ReplacementChannelConfigInit>> init_;
::mozilla::ipc::IPDLStructMember<LoadInfoArgs> loadInfo_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> originalURI_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<uint32_t>> contentDisposition_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsString>> contentDispositionFilename_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIPropertyBag2>> properties_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsDOMNavigationTiming>> timing_;
::mozilla::ipc::IPDLStructMember<nsString> srcdocData_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> baseUri_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<LoadingSessionHistoryInfo>> loadingSessionHistoryInfo_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsCString>> originalUriString_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<EarlyHintConnectArgs>> earlyHints_;
::mozilla::ipc::IPDLStructMember<uint64_t> channelId_;
::mozilla::ipc::IPDLStructMember<uint64_t> loadIdentifier_;
::mozilla::ipc::IPDLStructMember<uint32_t> registrarId_;
::mozilla::ipc::IPDLStructMember<uint32_t> newLoadFlags_;
::mozilla::ipc::IPDLStructMember<uint32_t> redirectMode_;
::mozilla::ipc::IPDLStructMember<uint32_t> redirectFlags_;
::mozilla::ipc::IPDLStructMember<uint32_t> loadStateExternalLoadFlags_;
::mozilla::ipc::IPDLStructMember<uint32_t> loadStateInternalLoadFlags_;
::mozilla::ipc::IPDLStructMember<uint32_t> loadStateLoadType_;
::mozilla::ipc::IPDLStructMember<uint32_t> earlyHintLinkType_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::RedirectToRealChannelArgs>
{
typedef ::mozilla::net::RedirectToRealChannelArgs 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 TimingStructArgs|
//
namespace mozilla {
namespace net {
class TimingStructArgs final
{
private:
typedef ::mozilla::TimeStamp TimeStamp;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
TimingStructArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT TimingStructArgs(
const TimeStamp& _domainLookupStart,
const TimeStamp& _domainLookupEnd,
const TimeStamp& _connectStart,
const TimeStamp& _tcpConnectEnd,
const TimeStamp& _secureConnectionStart,
const TimeStamp& _connectEnd,
const TimeStamp& _requestStart,
const TimeStamp& _responseStart,
const TimeStamp& _responseEnd,
const TimeStamp& _transactionPending) :
domainLookupStart_(_domainLookupStart),
domainLookupEnd_(_domainLookupEnd),
connectStart_(_connectStart),
tcpConnectEnd_(_tcpConnectEnd),
secureConnectionStart_(_secureConnectionStart),
connectEnd_(_connectEnd),
requestStart_(_requestStart),
responseStart_(_responseStart),
responseEnd_(_responseEnd),
transactionPending_(_transactionPending)
{
}
MOZ_IMPLICIT TimingStructArgs(
TimeStamp&& _domainLookupStart,
TimeStamp&& _domainLookupEnd,
TimeStamp&& _connectStart,
TimeStamp&& _tcpConnectEnd,
TimeStamp&& _secureConnectionStart,
TimeStamp&& _connectEnd,
TimeStamp&& _requestStart,
TimeStamp&& _responseStart,
TimeStamp&& _responseEnd,
TimeStamp&& _transactionPending) :
domainLookupStart_(std::move(_domainLookupStart)),
domainLookupEnd_(std::move(_domainLookupEnd)),
connectStart_(std::move(_connectStart)),
tcpConnectEnd_(std::move(_tcpConnectEnd)),
secureConnectionStart_(std::move(_secureConnectionStart)),
connectEnd_(std::move(_connectEnd)),
requestStart_(std::move(_requestStart)),
responseStart_(std::move(_responseStart)),
responseEnd_(std::move(_responseEnd)),
transactionPending_(std::move(_transactionPending))
{
}
TimeStamp&
domainLookupStart()
{
return domainLookupStart_;
}
const TimeStamp&
domainLookupStart() const
{
return domainLookupStart_;
}
TimeStamp&
domainLookupEnd()
{
return domainLookupEnd_;
}
const TimeStamp&
domainLookupEnd() const
{
return domainLookupEnd_;
}
TimeStamp&
connectStart()
{
return connectStart_;
}
const TimeStamp&
connectStart() const
{
return connectStart_;
}
TimeStamp&
tcpConnectEnd()
{
return tcpConnectEnd_;
}
const TimeStamp&
tcpConnectEnd() const
{
return tcpConnectEnd_;
}
TimeStamp&
secureConnectionStart()
{
return secureConnectionStart_;
}
const TimeStamp&
secureConnectionStart() const
{
return secureConnectionStart_;
}
TimeStamp&
connectEnd()
{
return connectEnd_;
}
const TimeStamp&
connectEnd() const
{
return connectEnd_;
}
TimeStamp&
requestStart()
{
return requestStart_;
}
const TimeStamp&
requestStart() const
{
return requestStart_;
}
TimeStamp&
responseStart()
{
return responseStart_;
}
const TimeStamp&
responseStart() const
{
return responseStart_;
}
TimeStamp&
responseEnd()
{
return responseEnd_;
}
const TimeStamp&
responseEnd() const
{
return responseEnd_;
}
TimeStamp&
transactionPending()
{
return transactionPending_;
}
const TimeStamp&
transactionPending() const
{
return transactionPending_;
}
private:
::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> connectStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> tcpConnectEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> secureConnectionStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> connectEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> requestStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> responseStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> responseEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> transactionPending_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::TimingStructArgs>
{
typedef ::mozilla::net::TimingStructArgs 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 ResourceTimingStructArgs|
//
namespace mozilla {
namespace net {
class ResourceTimingStructArgs final
{
private:
typedef ::mozilla::TimeStamp TimeStamp;
typedef ::uint64_t uint64_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ResourceTimingStructArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ResourceTimingStructArgs(
const TimeStamp& _domainLookupStart,
const TimeStamp& _domainLookupEnd,
const TimeStamp& _connectStart,
const TimeStamp& _tcpConnectEnd,
const TimeStamp& _secureConnectionStart,
const TimeStamp& _connectEnd,
const TimeStamp& _requestStart,
const TimeStamp& _responseStart,
const TimeStamp& _responseEnd,
const TimeStamp& _fetchStart,
const TimeStamp& _redirectStart,
const TimeStamp& _redirectEnd,
const uint64_t& _transferSize,
const uint64_t& _encodedBodySize,
const TimeStamp& _cacheReadStart,
const TimeStamp& _cacheReadEnd,
const TimeStamp& _transactionPending) :
domainLookupStart_(_domainLookupStart),
domainLookupEnd_(_domainLookupEnd),
connectStart_(_connectStart),
tcpConnectEnd_(_tcpConnectEnd),
secureConnectionStart_(_secureConnectionStart),
connectEnd_(_connectEnd),
requestStart_(_requestStart),
responseStart_(_responseStart),
responseEnd_(_responseEnd),
fetchStart_(_fetchStart),
redirectStart_(_redirectStart),
redirectEnd_(_redirectEnd),
cacheReadStart_(_cacheReadStart),
cacheReadEnd_(_cacheReadEnd),
transactionPending_(_transactionPending),
transferSize_(_transferSize),
encodedBodySize_(_encodedBodySize)
{
}
MOZ_IMPLICIT ResourceTimingStructArgs(
TimeStamp&& _domainLookupStart,
TimeStamp&& _domainLookupEnd,
TimeStamp&& _connectStart,
TimeStamp&& _tcpConnectEnd,
TimeStamp&& _secureConnectionStart,
TimeStamp&& _connectEnd,
TimeStamp&& _requestStart,
TimeStamp&& _responseStart,
TimeStamp&& _responseEnd,
TimeStamp&& _fetchStart,
TimeStamp&& _redirectStart,
TimeStamp&& _redirectEnd,
uint64_t&& _transferSize,
uint64_t&& _encodedBodySize,
TimeStamp&& _cacheReadStart,
TimeStamp&& _cacheReadEnd,
TimeStamp&& _transactionPending) :
domainLookupStart_(std::move(_domainLookupStart)),
domainLookupEnd_(std::move(_domainLookupEnd)),
connectStart_(std::move(_connectStart)),
tcpConnectEnd_(std::move(_tcpConnectEnd)),
secureConnectionStart_(std::move(_secureConnectionStart)),
connectEnd_(std::move(_connectEnd)),
requestStart_(std::move(_requestStart)),
responseStart_(std::move(_responseStart)),
responseEnd_(std::move(_responseEnd)),
fetchStart_(std::move(_fetchStart)),
redirectStart_(std::move(_redirectStart)),
redirectEnd_(std::move(_redirectEnd)),
cacheReadStart_(std::move(_cacheReadStart)),
cacheReadEnd_(std::move(_cacheReadEnd)),
transactionPending_(std::move(_transactionPending)),
transferSize_(std::move(_transferSize)),
encodedBodySize_(std::move(_encodedBodySize))
{
}
TimeStamp&
domainLookupStart()
{
return domainLookupStart_;
}
const TimeStamp&
domainLookupStart() const
{
return domainLookupStart_;
}
TimeStamp&
domainLookupEnd()
{
return domainLookupEnd_;
}
const TimeStamp&
domainLookupEnd() const
{
return domainLookupEnd_;
}
TimeStamp&
connectStart()
{
return connectStart_;
}
const TimeStamp&
connectStart() const
{
return connectStart_;
}
TimeStamp&
tcpConnectEnd()
{
return tcpConnectEnd_;
}
const TimeStamp&
tcpConnectEnd() const
{
return tcpConnectEnd_;
}
TimeStamp&
secureConnectionStart()
{
return secureConnectionStart_;
}
const TimeStamp&
secureConnectionStart() const
{
return secureConnectionStart_;
}
TimeStamp&
connectEnd()
{
return connectEnd_;
}
const TimeStamp&
connectEnd() const
{
return connectEnd_;
}
TimeStamp&
requestStart()
{
return requestStart_;
}
const TimeStamp&
requestStart() const
{
return requestStart_;
}
TimeStamp&
responseStart()
{
return responseStart_;
}
const TimeStamp&
responseStart() const
{
return responseStart_;
}
TimeStamp&
responseEnd()
{
return responseEnd_;
}
const TimeStamp&
responseEnd() const
{
return responseEnd_;
}
TimeStamp&
fetchStart()
{
return fetchStart_;
}
const TimeStamp&
fetchStart() const
{
return fetchStart_;
}
TimeStamp&
redirectStart()
{
return redirectStart_;
}
const TimeStamp&
redirectStart() const
{
return redirectStart_;
}
TimeStamp&
redirectEnd()
{
return redirectEnd_;
}
const TimeStamp&
redirectEnd() const
{
return redirectEnd_;
}
uint64_t&
transferSize()
{
return transferSize_;
}
const uint64_t&
transferSize() const
{
return transferSize_;
}
uint64_t&
encodedBodySize()
{
return encodedBodySize_;
}
const uint64_t&
encodedBodySize() const
{
return encodedBodySize_;
}
TimeStamp&
cacheReadStart()
{
return cacheReadStart_;
}
const TimeStamp&
cacheReadStart() const
{
return cacheReadStart_;
}
TimeStamp&
cacheReadEnd()
{
return cacheReadEnd_;
}
const TimeStamp&
cacheReadEnd() const
{
return cacheReadEnd_;
}
TimeStamp&
transactionPending()
{
return transactionPending_;
}
const TimeStamp&
transactionPending() const
{
return transactionPending_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> connectStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> tcpConnectEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> secureConnectionStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> connectEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> requestStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> responseStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> responseEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> fetchStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> redirectStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> redirectEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> cacheReadStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> cacheReadEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> transactionPending_;
::mozilla::ipc::IPDLStructMember<uint64_t> transferSize_;
::mozilla::ipc::IPDLStructMember<uint64_t> encodedBodySize_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::ResourceTimingStructArgs>
{
typedef ::mozilla::net::ResourceTimingStructArgs 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 HttpActivity|
//
namespace mozilla {
namespace net {
class HttpActivity final
{
private:
typedef ::nsCString nsCString;
typedef ::int32_t int32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
HttpActivity() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT HttpActivity(
const nsCString& _host,
const int32_t& _port,
const bool& _endToEndSSL) :
host_(_host),
endToEndSSL_(_endToEndSSL),
port_(_port)
{
}
MOZ_IMPLICIT HttpActivity(
nsCString&& _host,
int32_t&& _port,
bool&& _endToEndSSL) :
host_(std::move(_host)),
endToEndSSL_(std::move(_endToEndSSL)),
port_(std::move(_port))
{
}
nsCString&
host()
{
return host_;
}
const nsCString&
host() const
{
return host_;
}
int32_t&
port()
{
return port_;
}
const int32_t&
port() const
{
return port_;
}
bool&
endToEndSSL()
{
return endToEndSSL_;
}
const bool&
endToEndSSL() const
{
return endToEndSSL_;
}
private:
::mozilla::ipc::IPDLStructMember<nsCString> host_;
::mozilla::ipc::IPDLStructMember<bool> endToEndSSL_;
::mozilla::ipc::IPDLStructMember<int32_t> port_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpActivity>
{
typedef ::mozilla::net::HttpActivity 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 HttpConnectionActivity|
//
namespace mozilla {
namespace net {
class HttpConnectionActivity final
{
private:
typedef ::nsCString nsCString;
typedef ::int32_t int32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
HttpConnectionActivity() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT HttpConnectionActivity(
const nsCString& _connInfoKey,
const nsCString& _host,
const int32_t& _port,
const bool& _ssl,
const bool& _hasECH,
const bool& _isHttp3) :
connInfoKey_(_connInfoKey),
host_(_host),
ssl_(_ssl),
hasECH_(_hasECH),
isHttp3_(_isHttp3),
port_(_port)
{
}
MOZ_IMPLICIT HttpConnectionActivity(
nsCString&& _connInfoKey,
nsCString&& _host,
int32_t&& _port,
bool&& _ssl,
bool&& _hasECH,
bool&& _isHttp3) :
connInfoKey_(std::move(_connInfoKey)),
host_(std::move(_host)),
ssl_(std::move(_ssl)),
hasECH_(std::move(_hasECH)),
isHttp3_(std::move(_isHttp3)),
port_(std::move(_port))
{
}
nsCString&
connInfoKey()
{
return connInfoKey_;
}
const nsCString&
connInfoKey() const
{
return connInfoKey_;
}
nsCString&
host()
{
return host_;
}
const nsCString&
host() const
{
return host_;
}
int32_t&
port()
{
return port_;
}
const int32_t&
port() const
{
return port_;
}
bool&
ssl()
{
return ssl_;
}
const bool&
ssl() const
{
return ssl_;
}
bool&
hasECH()
{
return hasECH_;
}
const bool&
hasECH() const
{
return hasECH_;
}
bool&
isHttp3()
{
return isHttp3_;
}
const bool&
isHttp3() const
{
return isHttp3_;
}
private:
::mozilla::ipc::IPDLStructMember<nsCString> connInfoKey_;
::mozilla::ipc::IPDLStructMember<nsCString> host_;
::mozilla::ipc::IPDLStructMember<bool> ssl_;
::mozilla::ipc::IPDLStructMember<bool> hasECH_;
::mozilla::ipc::IPDLStructMember<bool> isHttp3_;
::mozilla::ipc::IPDLStructMember<int32_t> port_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpConnectionActivity>
{
typedef ::mozilla::net::HttpConnectionActivity 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 |union HttpActivityArgs|
//
namespace mozilla {
namespace net {
class HttpActivityArgs final
{
public:
enum Type {
T__None,
Tuint64_t = 1,
THttpActivity,
THttpConnectionActivity,
T__Last = THttpConnectionActivity
};
private:
typedef ::uint64_t uint64_t;
typedef ::mozilla::net::HttpActivity HttpActivity;
typedef ::mozilla::net::HttpConnectionActivity HttpConnectionActivity;
typedef uint64_t uint64_t__tdef;
typedef HttpActivity HttpActivity__tdef;
typedef HttpConnectionActivity HttpConnectionActivity__tdef;
uint64_t*
ptr_uint64_t()
{
return (&(mVuint64_t));
}
const uint64_t*
constptr_uint64_t() const
{
return (&(mVuint64_t));
}
HttpActivity*
ptr_HttpActivity()
{
return (&(mVHttpActivity));
}
const HttpActivity*
constptr_HttpActivity() const
{
return (&(mVHttpActivity));
}
HttpConnectionActivity*
ptr_HttpConnectionActivity()
{
return (&(mVHttpConnectionActivity));
}
const HttpConnectionActivity*
constptr_HttpConnectionActivity() const
{
return (&(mVHttpConnectionActivity));
}
void
MaybeDestroy();
void
AssertSanity() const
{
MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
}
void
AssertSanity(Type aType) const
{
AssertSanity();
MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
}
public:
MOZ_IMPLICIT HttpActivityArgs() :
mType(T__None)
{
}
MOZ_IMPLICIT HttpActivityArgs(const uint64_t& aOther);
MOZ_IMPLICIT HttpActivityArgs(uint64_t&& aOther);
MOZ_IMPLICIT HttpActivityArgs(const HttpActivity& aOther);
MOZ_IMPLICIT HttpActivityArgs(HttpActivity&& aOther);
MOZ_IMPLICIT HttpActivityArgs(const HttpConnectionActivity& aOther);
MOZ_IMPLICIT HttpActivityArgs(HttpConnectionActivity&& aOther);
MOZ_IMPLICIT HttpActivityArgs(const HttpActivityArgs& aOther);
MOZ_IMPLICIT HttpActivityArgs(HttpActivityArgs&& aOther);
~HttpActivityArgs();
Type
type() const
{
return mType;
}
HttpActivityArgs&
operator=(const uint64_t& aRhs);
HttpActivityArgs&
operator=(uint64_t&& aRhs);
HttpActivityArgs&
operator=(const HttpActivity& aRhs);
HttpActivityArgs&
operator=(HttpActivity&& aRhs);
HttpActivityArgs&
operator=(const HttpConnectionActivity& aRhs);
HttpActivityArgs&
operator=(HttpConnectionActivity&& aRhs);
HttpActivityArgs&
operator=(const HttpActivityArgs& aRhs);
HttpActivityArgs&
operator=(HttpActivityArgs&& aRhs);
uint64_t&
get_uint64_t()
{
AssertSanity(Tuint64_t);
return (*(ptr_uint64_t()));
}
const uint64_t&
get_uint64_t() const
{
AssertSanity(Tuint64_t);
return (*(constptr_uint64_t()));
}
operator uint64_t&()
{
return get_uint64_t();
}
operator const uint64_t&() const
{
return get_uint64_t();
}
HttpActivity&
get_HttpActivity()
{
AssertSanity(THttpActivity);
return (*(ptr_HttpActivity()));
}
const HttpActivity&
get_HttpActivity() const
{
AssertSanity(THttpActivity);
return (*(constptr_HttpActivity()));
}
operator HttpActivity&()
{
return get_HttpActivity();
}
operator const HttpActivity&() const
{
return get_HttpActivity();
}
HttpConnectionActivity&
get_HttpConnectionActivity()
{
AssertSanity(THttpConnectionActivity);
return (*(ptr_HttpConnectionActivity()));
}
const HttpConnectionActivity&
get_HttpConnectionActivity() const
{
AssertSanity(THttpConnectionActivity);
return (*(constptr_HttpConnectionActivity()));
}
operator HttpConnectionActivity&()
{
return get_HttpConnectionActivity();
}
operator const HttpConnectionActivity&() const
{
return get_HttpConnectionActivity();
}
private:
union {
uint64_t mVuint64_t;
HttpActivity mVHttpActivity;
HttpConnectionActivity mVHttpConnectionActivity;
};
Type mType;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpActivityArgs>
{
typedef ::mozilla::net::HttpActivityArgs 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 TransactionObserverResult|
//
namespace mozilla {
namespace net {
class TransactionObserverResult final
{
private:
typedef ::nsresult nsresult;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
TransactionObserverResult() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT TransactionObserverResult(
const bool& _versionOk,
const bool& _authOk,
const nsresult& _closeReason) :
versionOk_(_versionOk),
authOk_(_authOk),
closeReason_(_closeReason)
{
}
MOZ_IMPLICIT TransactionObserverResult(
bool&& _versionOk,
bool&& _authOk,
nsresult&& _closeReason) :
versionOk_(std::move(_versionOk)),
authOk_(std::move(_authOk)),
closeReason_(std::move(_closeReason))
{
}
bool&
versionOk()
{
return versionOk_;
}
const bool&
versionOk() const
{
return versionOk_;
}
bool&
authOk()
{
return authOk_;
}
const bool&
authOk() const
{
return authOk_;
}
nsresult&
closeReason()
{
return closeReason_;
}
const nsresult&
closeReason() const
{
return closeReason_;
}
private:
::mozilla::ipc::IPDLStructMember<bool> versionOk_;
::mozilla::ipc::IPDLStructMember<bool> authOk_;
::mozilla::ipc::IPDLStructMember<nsresult> closeReason_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::TransactionObserverResult>
{
typedef ::mozilla::net::TransactionObserverResult 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 SpeculativeConnectionOverriderArgs|
//
namespace mozilla {
namespace net {
class SpeculativeConnectionOverriderArgs final
{
private:
typedef ::uint32_t uint32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
SpeculativeConnectionOverriderArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT SpeculativeConnectionOverriderArgs(
const uint32_t& _parallelSpeculativeConnectLimit,
const bool& _ignoreIdle,
const bool& _isFromPredictor,
const bool& _allow1918) :
ignoreIdle_(_ignoreIdle),
isFromPredictor_(_isFromPredictor),
allow1918_(_allow1918),
parallelSpeculativeConnectLimit_(_parallelSpeculativeConnectLimit)
{
}
MOZ_IMPLICIT SpeculativeConnectionOverriderArgs(
uint32_t&& _parallelSpeculativeConnectLimit,
bool&& _ignoreIdle,
bool&& _isFromPredictor,
bool&& _allow1918) :
ignoreIdle_(std::move(_ignoreIdle)),
isFromPredictor_(std::move(_isFromPredictor)),
allow1918_(std::move(_allow1918)),
parallelSpeculativeConnectLimit_(std::move(_parallelSpeculativeConnectLimit))
{
}
uint32_t&
parallelSpeculativeConnectLimit()
{
return parallelSpeculativeConnectLimit_;
}
const uint32_t&
parallelSpeculativeConnectLimit() const
{
return parallelSpeculativeConnectLimit_;
}
bool&
ignoreIdle()
{
return ignoreIdle_;
}
const bool&
ignoreIdle() const
{
return ignoreIdle_;
}
bool&
isFromPredictor()
{
return isFromPredictor_;
}
const bool&
isFromPredictor() const
{
return isFromPredictor_;
}
bool&
allow1918()
{
return allow1918_;
}
const bool&
allow1918() const
{
return allow1918_;
}
private:
::mozilla::ipc::IPDLStructMember<bool> ignoreIdle_;
::mozilla::ipc::IPDLStructMember<bool> isFromPredictor_;
::mozilla::ipc::IPDLStructMember<bool> allow1918_;
::mozilla::ipc::IPDLStructMember<uint32_t> parallelSpeculativeConnectLimit_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::SpeculativeConnectionOverriderArgs>
{
typedef ::mozilla::net::SpeculativeConnectionOverriderArgs 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 GIOChannelOpenArgs|
//
namespace mozilla {
namespace net {
class GIOChannelOpenArgs final
{
private:
typedef ::mozilla::ipc::URIParams URIParams;
typedef ::uint64_t uint64_t;
typedef ::nsCString nsCString;
typedef ::mozilla::ipc::IPCStream IPCStream;
typedef ::mozilla::net::LoadInfoArgs LoadInfoArgs;
typedef ::uint32_t uint32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
GIOChannelOpenArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT GIOChannelOpenArgs(
const URIParams& _uri,
const uint64_t& _startPos,
const nsCString& _entityID,
const mozilla::Maybe<IPCStream>& _uploadStream,
const LoadInfoArgs& _loadInfo,
const uint32_t& _loadFlags) :
uri_(_uri),
entityID_(_entityID),
uploadStream_(_uploadStream),
loadInfo_(_loadInfo),
startPos_(_startPos),
loadFlags_(_loadFlags)
{
}
MOZ_IMPLICIT GIOChannelOpenArgs(
URIParams&& _uri,
uint64_t&& _startPos,
nsCString&& _entityID,
mozilla::Maybe<IPCStream>&& _uploadStream,
LoadInfoArgs&& _loadInfo,
uint32_t&& _loadFlags) :
uri_(std::move(_uri)),
entityID_(std::move(_entityID)),
uploadStream_(std::move(_uploadStream)),
loadInfo_(std::move(_loadInfo)),
startPos_(std::move(_startPos)),
loadFlags_(std::move(_loadFlags))
{
}
URIParams&
uri()
{
return uri_;
}
const URIParams&
uri() const
{
return uri_;
}
uint64_t&
startPos()
{
return startPos_;
}
const uint64_t&
startPos() const
{
return startPos_;
}
nsCString&
entityID()
{
return entityID_;
}
const nsCString&
entityID() const
{
return entityID_;
}
mozilla::Maybe<IPCStream>&
uploadStream()
{
return uploadStream_;
}
const mozilla::Maybe<IPCStream>&
uploadStream() const
{
return uploadStream_;
}
LoadInfoArgs&
loadInfo()
{
return loadInfo_;
}
const LoadInfoArgs&
loadInfo() const
{
return loadInfo_;
}
uint32_t&
loadFlags()
{
return loadFlags_;
}
const uint32_t&
loadFlags() const
{
return loadFlags_;
}
private:
::mozilla::ipc::IPDLStructMember<URIParams> uri_;
::mozilla::ipc::IPDLStructMember<nsCString> entityID_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCStream>> uploadStream_;
::mozilla::ipc::IPDLStructMember<LoadInfoArgs> loadInfo_;
::mozilla::ipc::IPDLStructMember<uint64_t> startPos_;
::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::GIOChannelOpenArgs>
{
typedef ::mozilla::net::GIOChannelOpenArgs 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 GIOChannelConnectArgs|
//
namespace mozilla {
namespace net {
class GIOChannelConnectArgs final
{
private:
typedef ::uint32_t uint32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
GIOChannelConnectArgs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT GIOChannelConnectArgs(const uint32_t& _channelId) :
channelId_(_channelId)
{
}
MOZ_IMPLICIT GIOChannelConnectArgs(uint32_t&& _channelId) :
channelId_(std::move(_channelId))
{
}
uint32_t&
channelId()
{
return channelId_;
}
const uint32_t&
channelId() const
{
return channelId_;
}
private:
::mozilla::ipc::IPDLStructMember<uint32_t> channelId_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::GIOChannelConnectArgs>
{
typedef ::mozilla::net::GIOChannelConnectArgs 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 |union GIOChannelCreationArgs|
//
namespace mozilla {
namespace net {
class GIOChannelCreationArgs final
{
public:
enum Type {
T__None,
TGIOChannelOpenArgs = 1,
TGIOChannelConnectArgs,
T__Last = TGIOChannelConnectArgs
};
private:
typedef ::mozilla::net::GIOChannelOpenArgs GIOChannelOpenArgs;
typedef ::mozilla::net::GIOChannelConnectArgs GIOChannelConnectArgs;
typedef GIOChannelOpenArgs GIOChannelOpenArgs__tdef;
typedef GIOChannelConnectArgs GIOChannelConnectArgs__tdef;
GIOChannelOpenArgs*
ptr_GIOChannelOpenArgs()
{
return (&(mVGIOChannelOpenArgs));
}
const GIOChannelOpenArgs*
constptr_GIOChannelOpenArgs() const
{
return (&(mVGIOChannelOpenArgs));
}
GIOChannelConnectArgs*
ptr_GIOChannelConnectArgs()
{
return (&(mVGIOChannelConnectArgs));
}
const GIOChannelConnectArgs*
constptr_GIOChannelConnectArgs() const
{
return (&(mVGIOChannelConnectArgs));
}
void
MaybeDestroy();
void
AssertSanity() const
{
MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
}
void
AssertSanity(Type aType) const
{
AssertSanity();
MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
}
public:
MOZ_IMPLICIT GIOChannelCreationArgs() :
mType(T__None)
{
}
MOZ_IMPLICIT GIOChannelCreationArgs(const GIOChannelOpenArgs& aOther);
MOZ_IMPLICIT GIOChannelCreationArgs(GIOChannelOpenArgs&& aOther);
MOZ_IMPLICIT GIOChannelCreationArgs(const GIOChannelConnectArgs& aOther);
MOZ_IMPLICIT GIOChannelCreationArgs(GIOChannelConnectArgs&& aOther);
MOZ_IMPLICIT GIOChannelCreationArgs(const GIOChannelCreationArgs& aOther);
MOZ_IMPLICIT GIOChannelCreationArgs(GIOChannelCreationArgs&& aOther);
~GIOChannelCreationArgs();
Type
type() const
{
return mType;
}
GIOChannelCreationArgs&
operator=(const GIOChannelOpenArgs& aRhs);
GIOChannelCreationArgs&
operator=(GIOChannelOpenArgs&& aRhs);
GIOChannelCreationArgs&
operator=(const GIOChannelConnectArgs& aRhs);
GIOChannelCreationArgs&
operator=(GIOChannelConnectArgs&& aRhs);
GIOChannelCreationArgs&
operator=(const GIOChannelCreationArgs& aRhs);
GIOChannelCreationArgs&
operator=(GIOChannelCreationArgs&& aRhs);
GIOChannelOpenArgs&
get_GIOChannelOpenArgs()
{
AssertSanity(TGIOChannelOpenArgs);
return (*(ptr_GIOChannelOpenArgs()));
}
const GIOChannelOpenArgs&
get_GIOChannelOpenArgs() const
{
AssertSanity(TGIOChannelOpenArgs);
return (*(constptr_GIOChannelOpenArgs()));
}
operator GIOChannelOpenArgs&()
{
return get_GIOChannelOpenArgs();
}
operator const GIOChannelOpenArgs&() const
{
return get_GIOChannelOpenArgs();
}
GIOChannelConnectArgs&
get_GIOChannelConnectArgs()
{
AssertSanity(TGIOChannelConnectArgs);
return (*(ptr_GIOChannelConnectArgs()));
}
const GIOChannelConnectArgs&
get_GIOChannelConnectArgs() const
{
AssertSanity(TGIOChannelConnectArgs);
return (*(constptr_GIOChannelConnectArgs()));
}
operator GIOChannelConnectArgs&()
{
return get_GIOChannelConnectArgs();
}
operator const GIOChannelConnectArgs&() const
{
return get_GIOChannelConnectArgs();
}
private:
union {
GIOChannelOpenArgs mVGIOChannelOpenArgs;
GIOChannelConnectArgs mVGIOChannelConnectArgs;
};
Type mType;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::GIOChannelCreationArgs>
{
typedef ::mozilla::net::GIOChannelCreationArgs 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 DataChannelInfo|
//
namespace mozilla {
namespace net {
class DataChannelInfo final
{
private:
typedef ::nsIURI nsIURI;
typedef ::uint32_t uint32_t;
typedef ::mozilla::net::LoadInfoArgs LoadInfoArgs;
typedef ::nsCString nsCString;
typedef ::uint64_t uint64_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
DataChannelInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT DataChannelInfo(
nsIURI* _uri,
const uint32_t& _loadFlags,
const LoadInfoArgs& _loadInfo,
const nsCString& _contentType,
const uint64_t& _channelId) :
uri_(_uri),
loadInfo_(_loadInfo),
contentType_(_contentType),
channelId_(_channelId),
loadFlags_(_loadFlags)
{
}
MOZ_IMPLICIT DataChannelInfo(
RefPtr<nsIURI>&& _uri,
uint32_t&& _loadFlags,
LoadInfoArgs&& _loadInfo,
nsCString&& _contentType,
uint64_t&& _channelId) :
uri_(std::move(_uri)),
loadInfo_(std::move(_loadInfo)),
contentType_(std::move(_contentType)),
channelId_(std::move(_channelId)),
loadFlags_(std::move(_loadFlags))
{
}
RefPtr<nsIURI>&
uri()
{
return uri_;
}
nsIURI*
uri() const
{
return uri_;
}
uint32_t&
loadFlags()
{
return loadFlags_;
}
const uint32_t&
loadFlags() const
{
return loadFlags_;
}
LoadInfoArgs&
loadInfo()
{
return loadInfo_;
}
const LoadInfoArgs&
loadInfo() const
{
return loadInfo_;
}
nsCString&
contentType()
{
return contentType_;
}
const nsCString&
contentType() const
{
return contentType_;
}
uint64_t&
channelId()
{
return channelId_;
}
const uint64_t&
channelId() const
{
return channelId_;
}
private:
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> uri_;
::mozilla::ipc::IPDLStructMember<LoadInfoArgs> loadInfo_;
::mozilla::ipc::IPDLStructMember<nsCString> contentType_;
::mozilla::ipc::IPDLStructMember<uint64_t> channelId_;
::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::DataChannelInfo>
{
typedef ::mozilla::net::DataChannelInfo 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 FileChannelInfo|
//
namespace mozilla {
namespace net {
class FileChannelInfo final
{
private:
typedef ::nsIURI nsIURI;
typedef ::uint32_t uint32_t;
typedef ::mozilla::net::LoadInfoArgs LoadInfoArgs;
typedef ::nsCString nsCString;
typedef ::uint64_t uint64_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
FileChannelInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT FileChannelInfo(
nsIURI* _uri,
nsIURI* _originalURI,
const uint32_t& _loadFlags,
const LoadInfoArgs& _loadInfo,
const nsCString& _contentType,
const uint64_t& _channelId) :
uri_(_uri),
originalURI_(_originalURI),
loadInfo_(_loadInfo),
contentType_(_contentType),
channelId_(_channelId),
loadFlags_(_loadFlags)
{
}
MOZ_IMPLICIT FileChannelInfo(
RefPtr<nsIURI>&& _uri,
RefPtr<nsIURI>&& _originalURI,
uint32_t&& _loadFlags,
LoadInfoArgs&& _loadInfo,
nsCString&& _contentType,
uint64_t&& _channelId) :
uri_(std::move(_uri)),
originalURI_(std::move(_originalURI)),
loadInfo_(std::move(_loadInfo)),
contentType_(std::move(_contentType)),
channelId_(std::move(_channelId)),
loadFlags_(std::move(_loadFlags))
{
}
RefPtr<nsIURI>&
uri()
{
return uri_;
}
nsIURI*
uri() const
{
return uri_;
}
RefPtr<nsIURI>&
originalURI()
{
return originalURI_;
}
nsIURI*
originalURI() const
{
return originalURI_;
}
uint32_t&
loadFlags()
{
return loadFlags_;
}
const uint32_t&
loadFlags() const
{
return loadFlags_;
}
LoadInfoArgs&
loadInfo()
{
return loadInfo_;
}
const LoadInfoArgs&
loadInfo() const
{
return loadInfo_;
}
nsCString&
contentType()
{
return contentType_;
}
const nsCString&
contentType() const
{
return contentType_;
}
uint64_t&
channelId()
{
return channelId_;
}
const uint64_t&
channelId() const
{
return channelId_;
}
private:
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> uri_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> originalURI_;
::mozilla::ipc::IPDLStructMember<LoadInfoArgs> loadInfo_;
::mozilla::ipc::IPDLStructMember<nsCString> contentType_;
::mozilla::ipc::IPDLStructMember<uint64_t> channelId_;
::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::FileChannelInfo>
{
typedef ::mozilla::net::FileChannelInfo 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 RemoteStreamInfo|
//
namespace mozilla {
namespace net {
class RemoteStreamInfo final
{
private:
typedef ::nsIInputStream nsIInputStream;
typedef ::nsCString nsCString;
typedef ::int64_t int64_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
RemoteStreamInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT RemoteStreamInfo(
nsIInputStream* _inputStream,
const nsCString& _contentType,
const int64_t& _contentLength) :
inputStream_(_inputStream),
contentType_(_contentType),
contentLength_(_contentLength)
{
}
MOZ_IMPLICIT RemoteStreamInfo(
RefPtr<nsIInputStream>&& _inputStream,
nsCString&& _contentType,
int64_t&& _contentLength) :
inputStream_(std::move(_inputStream)),
contentType_(std::move(_contentType)),
contentLength_(std::move(_contentLength))
{
}
RefPtr<nsIInputStream>&
inputStream()
{
return inputStream_;
}
nsIInputStream*
inputStream() const
{
return inputStream_;
}
nsCString&
contentType()
{
return contentType_;
}
const nsCString&
contentType() const
{
return contentType_;
}
int64_t&
contentLength()
{
return contentLength_;
}
const int64_t&
contentLength() const
{
return contentLength_;
}
private:
::mozilla::ipc::IPDLStructMember<RefPtr<nsIInputStream>> inputStream_;
::mozilla::ipc::IPDLStructMember<nsCString> contentType_;
::mozilla::ipc::IPDLStructMember<int64_t> contentLength_;
};
} // namespace net
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::net::RemoteStreamInfo>
{
typedef ::mozilla::net::RemoteStreamInfo paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
#endif // ifndef NeckoChannelParams_h