//
// Automatically generated by ipdlc.
// Edit at your own risk
//

#ifndef HttpChannelParams_h
#define HttpChannelParams_h

#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"

// Headers for typedefs
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/net/DNS.h"
#include "nsICacheInfoChannel.h"
#include "nsILoadInfo.h"
#include "nsIReferrerInfo.h"
#include "nsIRequest.h"
#include "nsITRRSkipReason.h"
#include "nsITransportSecurityInfo.h"
#include "mozilla/dom/IPCServiceWorkerDescriptor.h"
#include "mozilla/net/NeckoChannelParams.h"
#include "mozilla/ipc/IPCStream.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct HttpChannelOnStartRequestArgs|
//
namespace mozilla {
namespace net {
class HttpChannelOnStartRequestArgs final
{
private:
    typedef ::nsITransportSecurityInfo nsITransportSecurityInfo;
    typedef ::nsIReferrerInfo nsIReferrerInfo;
    typedef ::uint64_t uint64_t;
    typedef ::int64_t int64_t;
    typedef ::nsCString nsCString;
    typedef ::mozilla::net::CookieChange CookieChange;
    typedef ::mozilla::net::NetAddr NetAddr;
    typedef ::mozilla::net::ResourceTimingStructArgs ResourceTimingStructArgs;
    typedef ::mozilla::net::ParentLoadInfoForwarderArgs ParentLoadInfoForwarderArgs;
    typedef ::nsresult nsresult;
    typedef ::nsIRequest::TRRMode TRRMode;
    typedef ::mozilla::net::TRRSkippedReason TRRSkippedReason;
    typedef ::uint32_t uint32_t;
    typedef ::nsILoadInfo::CrossOriginOpenerPolicy CrossOriginOpenerPolicy;
    typedef ::uint8_t uint8_t;
    typedef ::nsICacheInfoChannel::CacheDisposition CacheDisposition;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    HttpChannelOnStartRequestArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT HttpChannelOnStartRequestArgs(
            nsITransportSecurityInfo* _securityInfo,
            nsIReferrerInfo* _overrideReferrerInfo,
            const uint64_t& _cacheEntryId,
            const int64_t& _altDataLength,
            const nsCString& _altDataType,
            const nsTArray<CookieChange>& _cookieChanges,
            const NetAddr& _selfAddr,
            const NetAddr& _peerAddr,
            const ResourceTimingStructArgs& _timing,
            const ParentLoadInfoForwarderArgs& _loadInfoForwarder,
            const nsresult& _channelStatus,
            const TRRMode& _effectiveTRRMode,
            const TRRSkippedReason& _trrSkipReason,
            const uint32_t& _cacheFetchCount,
            const uint32_t& _cacheExpirationTime,
            const uint32_t& _cacheKey,
            const mozilla::Maybe<uint32_t>& _multiPartID,
            const bool& _isFromCache,
            const bool& _isRacing,
            const bool& _cacheEntryAvailable,
            const bool& _deliveringAltData,
            const bool& _applyConversion,
            const bool& _isResolvedByTRR,
            const bool& _allRedirectsSameOrigin,
            const bool& _isFirstPartOfMultiPart,
            const bool& _isLastPartOfMultiPart,
            const CrossOriginOpenerPolicy& _openerPolicy,
            const bool& _shouldWaitForOnStartRequestSent,
            const bool& _dataFromSocketProcess,
            const bool& _hasHTTPSRR,
            const bool& _isProxyUsed,
            const uint8_t& _redirectCount,
            const nsCString& _protocolVersion,
            const CacheDisposition& _cacheDisposition) :
        securityInfo_(_securityInfo),
        overrideReferrerInfo_(_overrideReferrerInfo),
        altDataType_(_altDataType),
        cookieChanges_(_cookieChanges),
        selfAddr_(_selfAddr),
        peerAddr_(_peerAddr),
        timing_(_timing),
        loadInfoForwarder_(_loadInfoForwarder),
        channelStatus_(_channelStatus),
        effectiveTRRMode_(_effectiveTRRMode),
        trrSkipReason_(_trrSkipReason),
        multiPartID_(_multiPartID),
        isFromCache_(_isFromCache),
        isRacing_(_isRacing),
        cacheEntryAvailable_(_cacheEntryAvailable),
        deliveringAltData_(_deliveringAltData),
        applyConversion_(_applyConversion),
        isResolvedByTRR_(_isResolvedByTRR),
        allRedirectsSameOrigin_(_allRedirectsSameOrigin),
        isFirstPartOfMultiPart_(_isFirstPartOfMultiPart),
        isLastPartOfMultiPart_(_isLastPartOfMultiPart),
        openerPolicy_(_openerPolicy),
        shouldWaitForOnStartRequestSent_(_shouldWaitForOnStartRequestSent),
        dataFromSocketProcess_(_dataFromSocketProcess),
        hasHTTPSRR_(_hasHTTPSRR),
        isProxyUsed_(_isProxyUsed),
        protocolVersion_(_protocolVersion),
        cacheDisposition_(_cacheDisposition),
        cacheEntryId_(_cacheEntryId),
        altDataLength_(_altDataLength),
        cacheFetchCount_(_cacheFetchCount),
        cacheExpirationTime_(_cacheExpirationTime),
        cacheKey_(_cacheKey),
        redirectCount_(_redirectCount)
    {
    }

    MOZ_IMPLICIT HttpChannelOnStartRequestArgs(
            RefPtr<nsITransportSecurityInfo>&& _securityInfo,
            RefPtr<nsIReferrerInfo>&& _overrideReferrerInfo,
            uint64_t&& _cacheEntryId,
            int64_t&& _altDataLength,
            nsCString&& _altDataType,
            nsTArray<CookieChange>&& _cookieChanges,
            NetAddr&& _selfAddr,
            NetAddr&& _peerAddr,
            ResourceTimingStructArgs&& _timing,
            ParentLoadInfoForwarderArgs&& _loadInfoForwarder,
            nsresult&& _channelStatus,
            TRRMode&& _effectiveTRRMode,
            TRRSkippedReason&& _trrSkipReason,
            uint32_t&& _cacheFetchCount,
            uint32_t&& _cacheExpirationTime,
            uint32_t&& _cacheKey,
            mozilla::Maybe<uint32_t>&& _multiPartID,
            bool&& _isFromCache,
            bool&& _isRacing,
            bool&& _cacheEntryAvailable,
            bool&& _deliveringAltData,
            bool&& _applyConversion,
            bool&& _isResolvedByTRR,
            bool&& _allRedirectsSameOrigin,
            bool&& _isFirstPartOfMultiPart,
            bool&& _isLastPartOfMultiPart,
            CrossOriginOpenerPolicy&& _openerPolicy,
            bool&& _shouldWaitForOnStartRequestSent,
            bool&& _dataFromSocketProcess,
            bool&& _hasHTTPSRR,
            bool&& _isProxyUsed,
            uint8_t&& _redirectCount,
            nsCString&& _protocolVersion,
            CacheDisposition&& _cacheDisposition) :
        securityInfo_(std::move(_securityInfo)),
        overrideReferrerInfo_(std::move(_overrideReferrerInfo)),
        altDataType_(std::move(_altDataType)),
        cookieChanges_(std::move(_cookieChanges)),
        selfAddr_(std::move(_selfAddr)),
        peerAddr_(std::move(_peerAddr)),
        timing_(std::move(_timing)),
        loadInfoForwarder_(std::move(_loadInfoForwarder)),
        channelStatus_(std::move(_channelStatus)),
        effectiveTRRMode_(std::move(_effectiveTRRMode)),
        trrSkipReason_(std::move(_trrSkipReason)),
        multiPartID_(std::move(_multiPartID)),
        isFromCache_(std::move(_isFromCache)),
        isRacing_(std::move(_isRacing)),
        cacheEntryAvailable_(std::move(_cacheEntryAvailable)),
        deliveringAltData_(std::move(_deliveringAltData)),
        applyConversion_(std::move(_applyConversion)),
        isResolvedByTRR_(std::move(_isResolvedByTRR)),
        allRedirectsSameOrigin_(std::move(_allRedirectsSameOrigin)),
        isFirstPartOfMultiPart_(std::move(_isFirstPartOfMultiPart)),
        isLastPartOfMultiPart_(std::move(_isLastPartOfMultiPart)),
        openerPolicy_(std::move(_openerPolicy)),
        shouldWaitForOnStartRequestSent_(std::move(_shouldWaitForOnStartRequestSent)),
        dataFromSocketProcess_(std::move(_dataFromSocketProcess)),
        hasHTTPSRR_(std::move(_hasHTTPSRR)),
        isProxyUsed_(std::move(_isProxyUsed)),
        protocolVersion_(std::move(_protocolVersion)),
        cacheDisposition_(std::move(_cacheDisposition)),
        cacheEntryId_(std::move(_cacheEntryId)),
        altDataLength_(std::move(_altDataLength)),
        cacheFetchCount_(std::move(_cacheFetchCount)),
        cacheExpirationTime_(std::move(_cacheExpirationTime)),
        cacheKey_(std::move(_cacheKey)),
        redirectCount_(std::move(_redirectCount))
    {
    }

    RefPtr<nsITransportSecurityInfo>&
    securityInfo()
    {
        return securityInfo_;
    }
    nsITransportSecurityInfo*
    securityInfo() const
    {
        return securityInfo_;
    }

    RefPtr<nsIReferrerInfo>&
    overrideReferrerInfo()
    {
        return overrideReferrerInfo_;
    }
    nsIReferrerInfo*
    overrideReferrerInfo() const
    {
        return overrideReferrerInfo_;
    }

    uint64_t&
    cacheEntryId()
    {
        return cacheEntryId_;
    }
    const uint64_t&
    cacheEntryId() const
    {
        return cacheEntryId_;
    }

    int64_t&
    altDataLength()
    {
        return altDataLength_;
    }
    const int64_t&
    altDataLength() const
    {
        return altDataLength_;
    }

    nsCString&
    altDataType()
    {
        return altDataType_;
    }
    const nsCString&
    altDataType() const
    {
        return altDataType_;
    }

    nsTArray<CookieChange>&
    cookieChanges()
    {
        return cookieChanges_;
    }
    const nsTArray<CookieChange>&
    cookieChanges() const
    {
        return cookieChanges_;
    }

    NetAddr&
    selfAddr()
    {
        return selfAddr_;
    }
    const NetAddr&
    selfAddr() const
    {
        return selfAddr_;
    }

    NetAddr&
    peerAddr()
    {
        return peerAddr_;
    }
    const NetAddr&
    peerAddr() const
    {
        return peerAddr_;
    }

    ResourceTimingStructArgs&
    timing()
    {
        return timing_;
    }
    const ResourceTimingStructArgs&
    timing() const
    {
        return timing_;
    }

    ParentLoadInfoForwarderArgs&
    loadInfoForwarder()
    {
        return loadInfoForwarder_;
    }
    const ParentLoadInfoForwarderArgs&
    loadInfoForwarder() const
    {
        return loadInfoForwarder_;
    }

    nsresult&
    channelStatus()
    {
        return channelStatus_;
    }
    const nsresult&
    channelStatus() const
    {
        return channelStatus_;
    }

    TRRMode&
    effectiveTRRMode()
    {
        return effectiveTRRMode_;
    }
    const TRRMode&
    effectiveTRRMode() const
    {
        return effectiveTRRMode_;
    }

    TRRSkippedReason&
    trrSkipReason()
    {
        return trrSkipReason_;
    }
    const TRRSkippedReason&
    trrSkipReason() const
    {
        return trrSkipReason_;
    }

    uint32_t&
    cacheFetchCount()
    {
        return cacheFetchCount_;
    }
    const uint32_t&
    cacheFetchCount() const
    {
        return cacheFetchCount_;
    }

    uint32_t&
    cacheExpirationTime()
    {
        return cacheExpirationTime_;
    }
    const uint32_t&
    cacheExpirationTime() const
    {
        return cacheExpirationTime_;
    }

    uint32_t&
    cacheKey()
    {
        return cacheKey_;
    }
    const uint32_t&
    cacheKey() const
    {
        return cacheKey_;
    }

    mozilla::Maybe<uint32_t>&
    multiPartID()
    {
        return multiPartID_;
    }
    const mozilla::Maybe<uint32_t>&
    multiPartID() const
    {
        return multiPartID_;
    }

    bool&
    isFromCache()
    {
        return isFromCache_;
    }
    const bool&
    isFromCache() const
    {
        return isFromCache_;
    }

    bool&
    isRacing()
    {
        return isRacing_;
    }
    const bool&
    isRacing() const
    {
        return isRacing_;
    }

    bool&
    cacheEntryAvailable()
    {
        return cacheEntryAvailable_;
    }
    const bool&
    cacheEntryAvailable() const
    {
        return cacheEntryAvailable_;
    }

    bool&
    deliveringAltData()
    {
        return deliveringAltData_;
    }
    const bool&
    deliveringAltData() const
    {
        return deliveringAltData_;
    }

    bool&
    applyConversion()
    {
        return applyConversion_;
    }
    const bool&
    applyConversion() const
    {
        return applyConversion_;
    }

    bool&
    isResolvedByTRR()
    {
        return isResolvedByTRR_;
    }
    const bool&
    isResolvedByTRR() const
    {
        return isResolvedByTRR_;
    }

    bool&
    allRedirectsSameOrigin()
    {
        return allRedirectsSameOrigin_;
    }
    const bool&
    allRedirectsSameOrigin() const
    {
        return allRedirectsSameOrigin_;
    }

    bool&
    isFirstPartOfMultiPart()
    {
        return isFirstPartOfMultiPart_;
    }
    const bool&
    isFirstPartOfMultiPart() const
    {
        return isFirstPartOfMultiPart_;
    }

    bool&
    isLastPartOfMultiPart()
    {
        return isLastPartOfMultiPart_;
    }
    const bool&
    isLastPartOfMultiPart() const
    {
        return isLastPartOfMultiPart_;
    }

    CrossOriginOpenerPolicy&
    openerPolicy()
    {
        return openerPolicy_;
    }
    const CrossOriginOpenerPolicy&
    openerPolicy() const
    {
        return openerPolicy_;
    }

    bool&
    shouldWaitForOnStartRequestSent()
    {
        return shouldWaitForOnStartRequestSent_;
    }
    const bool&
    shouldWaitForOnStartRequestSent() const
    {
        return shouldWaitForOnStartRequestSent_;
    }

    bool&
    dataFromSocketProcess()
    {
        return dataFromSocketProcess_;
    }
    const bool&
    dataFromSocketProcess() const
    {
        return dataFromSocketProcess_;
    }

    bool&
    hasHTTPSRR()
    {
        return hasHTTPSRR_;
    }
    const bool&
    hasHTTPSRR() const
    {
        return hasHTTPSRR_;
    }

    bool&
    isProxyUsed()
    {
        return isProxyUsed_;
    }
    const bool&
    isProxyUsed() const
    {
        return isProxyUsed_;
    }

    uint8_t&
    redirectCount()
    {
        return redirectCount_;
    }
    const uint8_t&
    redirectCount() const
    {
        return redirectCount_;
    }

    nsCString&
    protocolVersion()
    {
        return protocolVersion_;
    }
    const nsCString&
    protocolVersion() const
    {
        return protocolVersion_;
    }

    CacheDisposition&
    cacheDisposition()
    {
        return cacheDisposition_;
    }
    const CacheDisposition&
    cacheDisposition() const
    {
        return cacheDisposition_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsITransportSecurityInfo>> securityInfo_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIReferrerInfo>> overrideReferrerInfo_;
    ::mozilla::ipc::IPDLStructMember<nsCString> altDataType_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<CookieChange>> cookieChanges_;
    ::mozilla::ipc::IPDLStructMember<NetAddr> selfAddr_;
    ::mozilla::ipc::IPDLStructMember<NetAddr> peerAddr_;
    ::mozilla::ipc::IPDLStructMember<ResourceTimingStructArgs> timing_;
    ::mozilla::ipc::IPDLStructMember<ParentLoadInfoForwarderArgs> loadInfoForwarder_;
    ::mozilla::ipc::IPDLStructMember<nsresult> channelStatus_;
    ::mozilla::ipc::IPDLStructMember<TRRMode> effectiveTRRMode_;
    ::mozilla::ipc::IPDLStructMember<TRRSkippedReason> trrSkipReason_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<uint32_t>> multiPartID_;
    ::mozilla::ipc::IPDLStructMember<bool> isFromCache_;
    ::mozilla::ipc::IPDLStructMember<bool> isRacing_;
    ::mozilla::ipc::IPDLStructMember<bool> cacheEntryAvailable_;
    ::mozilla::ipc::IPDLStructMember<bool> deliveringAltData_;
    ::mozilla::ipc::IPDLStructMember<bool> applyConversion_;
    ::mozilla::ipc::IPDLStructMember<bool> isResolvedByTRR_;
    ::mozilla::ipc::IPDLStructMember<bool> allRedirectsSameOrigin_;
    ::mozilla::ipc::IPDLStructMember<bool> isFirstPartOfMultiPart_;
    ::mozilla::ipc::IPDLStructMember<bool> isLastPartOfMultiPart_;
    ::mozilla::ipc::IPDLStructMember<CrossOriginOpenerPolicy> openerPolicy_;
    ::mozilla::ipc::IPDLStructMember<bool> shouldWaitForOnStartRequestSent_;
    ::mozilla::ipc::IPDLStructMember<bool> dataFromSocketProcess_;
    ::mozilla::ipc::IPDLStructMember<bool> hasHTTPSRR_;
    ::mozilla::ipc::IPDLStructMember<bool> isProxyUsed_;
    ::mozilla::ipc::IPDLStructMember<nsCString> protocolVersion_;
    ::mozilla::ipc::IPDLStructMember<CacheDisposition> cacheDisposition_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> cacheEntryId_;
    ::mozilla::ipc::IPDLStructMember<int64_t> altDataLength_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> cacheFetchCount_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> cacheExpirationTime_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> cacheKey_;
    ::mozilla::ipc::IPDLStructMember<uint8_t> redirectCount_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpChannelOnStartRequestArgs>
{
    typedef ::mozilla::net::HttpChannelOnStartRequestArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct HttpChannelAltDataStream|
//
namespace mozilla {
namespace net {
class HttpChannelAltDataStream final
{
private:
    typedef ::mozilla::ipc::IPCStream IPCStream;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    HttpChannelAltDataStream() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT HttpChannelAltDataStream(const mozilla::Maybe<IPCStream>& _altDataInputStream) :
        altDataInputStream_(_altDataInputStream)
    {
    }

    MOZ_IMPLICIT HttpChannelAltDataStream(mozilla::Maybe<IPCStream>&& _altDataInputStream) :
        altDataInputStream_(std::move(_altDataInputStream))
    {
    }

    mozilla::Maybe<IPCStream>&
    altDataInputStream()
    {
        return altDataInputStream_;
    }
    const mozilla::Maybe<IPCStream>&
    altDataInputStream() const
    {
        return altDataInputStream_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCStream>> altDataInputStream_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpChannelAltDataStream>
{
    typedef ::mozilla::net::HttpChannelAltDataStream paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC

#endif // ifndef HttpChannelParams_h
