//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef PWebTransport_h
#define PWebTransport_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/DataPipe.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/ipc/PBackgroundSharedTypes.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct UnidirectionalStream|
//
namespace mozilla {
namespace dom {
class UnidirectionalStream final
{
private:
typedef ::uint64_t uint64_t;
typedef ::mozilla::ipc::DataPipeSender DataPipeSender;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
UnidirectionalStream() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT UnidirectionalStream(
const uint64_t& _streamId,
DataPipeSender* _outStream) :
outStream_(_outStream),
streamId_(_streamId)
{
}
MOZ_IMPLICIT UnidirectionalStream(
uint64_t&& _streamId,
RefPtr<DataPipeSender>&& _outStream) :
outStream_(std::move(_outStream)),
streamId_(std::move(_streamId))
{
}
uint64_t&
streamId()
{
return streamId_;
}
const uint64_t&
streamId() const
{
return streamId_;
}
RefPtr<DataPipeSender>&
outStream()
{
return outStream_;
}
DataPipeSender*
outStream() const
{
return outStream_;
}
private:
::mozilla::ipc::IPDLStructMember<RefPtr<DataPipeSender>> outStream_;
::mozilla::ipc::IPDLStructMember<uint64_t> streamId_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::UnidirectionalStream>
{
typedef ::mozilla::dom::UnidirectionalStream 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 UnidirectionalStreamResponse|
//
namespace mozilla {
namespace dom {
class UnidirectionalStreamResponse final
{
public:
enum Type {
T__None,
Tnsresult = 1,
TUnidirectionalStream,
T__Last = TUnidirectionalStream
};
private:
typedef ::nsresult nsresult;
typedef ::mozilla::dom::UnidirectionalStream UnidirectionalStream;
typedef nsresult nsresult__tdef;
typedef UnidirectionalStream UnidirectionalStream__tdef;
nsresult*
ptr_nsresult()
{
return (&(mVnsresult));
}
const nsresult*
constptr_nsresult() const
{
return (&(mVnsresult));
}
UnidirectionalStream*
ptr_UnidirectionalStream()
{
return (&(mVUnidirectionalStream));
}
const UnidirectionalStream*
constptr_UnidirectionalStream() const
{
return (&(mVUnidirectionalStream));
}
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 UnidirectionalStreamResponse() :
mType(T__None)
{
}
MOZ_IMPLICIT UnidirectionalStreamResponse(const nsresult& aOther);
MOZ_IMPLICIT UnidirectionalStreamResponse(nsresult&& aOther);
MOZ_IMPLICIT UnidirectionalStreamResponse(const UnidirectionalStream& aOther);
MOZ_IMPLICIT UnidirectionalStreamResponse(UnidirectionalStream&& aOther);
MOZ_IMPLICIT UnidirectionalStreamResponse(const UnidirectionalStreamResponse& aOther);
MOZ_IMPLICIT UnidirectionalStreamResponse(UnidirectionalStreamResponse&& aOther);
~UnidirectionalStreamResponse();
Type
type() const
{
return mType;
}
UnidirectionalStreamResponse&
operator=(const nsresult& aRhs);
UnidirectionalStreamResponse&
operator=(nsresult&& aRhs);
UnidirectionalStreamResponse&
operator=(const UnidirectionalStream& aRhs);
UnidirectionalStreamResponse&
operator=(UnidirectionalStream&& aRhs);
UnidirectionalStreamResponse&
operator=(const UnidirectionalStreamResponse& aRhs);
UnidirectionalStreamResponse&
operator=(UnidirectionalStreamResponse&& aRhs);
nsresult&
get_nsresult()
{
AssertSanity(Tnsresult);
return (*(ptr_nsresult()));
}
const nsresult&
get_nsresult() const
{
AssertSanity(Tnsresult);
return (*(constptr_nsresult()));
}
operator nsresult&()
{
return get_nsresult();
}
operator const nsresult&() const
{
return get_nsresult();
}
UnidirectionalStream&
get_UnidirectionalStream()
{
AssertSanity(TUnidirectionalStream);
return (*(ptr_UnidirectionalStream()));
}
const UnidirectionalStream&
get_UnidirectionalStream() const
{
AssertSanity(TUnidirectionalStream);
return (*(constptr_UnidirectionalStream()));
}
operator UnidirectionalStream&()
{
return get_UnidirectionalStream();
}
operator const UnidirectionalStream&() const
{
return get_UnidirectionalStream();
}
private:
union {
nsresult mVnsresult;
UnidirectionalStream mVUnidirectionalStream;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::UnidirectionalStreamResponse>
{
typedef ::mozilla::dom::UnidirectionalStreamResponse 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 BidirectionalStream|
//
namespace mozilla {
namespace dom {
class BidirectionalStream final
{
private:
typedef ::uint64_t uint64_t;
typedef ::mozilla::ipc::DataPipeReceiver DataPipeReceiver;
typedef ::mozilla::ipc::DataPipeSender DataPipeSender;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
BidirectionalStream() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT BidirectionalStream(
const uint64_t& _streamId,
DataPipeReceiver* _inStream,
DataPipeSender* _outStream) :
inStream_(_inStream),
outStream_(_outStream),
streamId_(_streamId)
{
}
MOZ_IMPLICIT BidirectionalStream(
uint64_t&& _streamId,
RefPtr<DataPipeReceiver>&& _inStream,
RefPtr<DataPipeSender>&& _outStream) :
inStream_(std::move(_inStream)),
outStream_(std::move(_outStream)),
streamId_(std::move(_streamId))
{
}
uint64_t&
streamId()
{
return streamId_;
}
const uint64_t&
streamId() const
{
return streamId_;
}
RefPtr<DataPipeReceiver>&
inStream()
{
return inStream_;
}
DataPipeReceiver*
inStream() const
{
return inStream_;
}
RefPtr<DataPipeSender>&
outStream()
{
return outStream_;
}
DataPipeSender*
outStream() const
{
return outStream_;
}
private:
::mozilla::ipc::IPDLStructMember<RefPtr<DataPipeReceiver>> inStream_;
::mozilla::ipc::IPDLStructMember<RefPtr<DataPipeSender>> outStream_;
::mozilla::ipc::IPDLStructMember<uint64_t> streamId_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::BidirectionalStream>
{
typedef ::mozilla::dom::BidirectionalStream 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 WebTransportDatagramStatsData|
//
namespace mozilla {
namespace dom {
class WebTransportDatagramStatsData final
{
private:
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
WebTransportDatagramStatsData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebTransportDatagramStatsData(
const uint64_t& _droppedIncoming,
const uint64_t& _expiredIncoming,
const uint64_t& _expiredOutgoing,
const uint64_t& _lostOutgoing) :
droppedIncoming_(_droppedIncoming),
expiredIncoming_(_expiredIncoming),
expiredOutgoing_(_expiredOutgoing),
lostOutgoing_(_lostOutgoing)
{
}
MOZ_IMPLICIT WebTransportDatagramStatsData(
uint64_t&& _droppedIncoming,
uint64_t&& _expiredIncoming,
uint64_t&& _expiredOutgoing,
uint64_t&& _lostOutgoing) :
droppedIncoming_(std::move(_droppedIncoming)),
expiredIncoming_(std::move(_expiredIncoming)),
expiredOutgoing_(std::move(_expiredOutgoing)),
lostOutgoing_(std::move(_lostOutgoing))
{
}
uint64_t&
droppedIncoming()
{
return droppedIncoming_;
}
const uint64_t&
droppedIncoming() const
{
return droppedIncoming_;
}
uint64_t&
expiredIncoming()
{
return expiredIncoming_;
}
const uint64_t&
expiredIncoming() const
{
return expiredIncoming_;
}
uint64_t&
expiredOutgoing()
{
return expiredOutgoing_;
}
const uint64_t&
expiredOutgoing() const
{
return expiredOutgoing_;
}
uint64_t&
lostOutgoing()
{
return lostOutgoing_;
}
const uint64_t&
lostOutgoing() const
{
return lostOutgoing_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<uint64_t> droppedIncoming_;
::mozilla::ipc::IPDLStructMember<uint64_t> expiredIncoming_;
::mozilla::ipc::IPDLStructMember<uint64_t> expiredOutgoing_;
::mozilla::ipc::IPDLStructMember<uint64_t> lostOutgoing_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebTransportDatagramStatsData>
{
typedef ::mozilla::dom::WebTransportDatagramStatsData 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 WebTransportStatsData|
//
namespace mozilla {
namespace dom {
class WebTransportStatsData final
{
private:
typedef ::uint64_t uint64_t;
typedef ::int64_t int64_t;
typedef ::mozilla::dom::WebTransportDatagramStatsData WebTransportDatagramStatsData;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebTransportStatsData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebTransportStatsData(
const uint64_t& _bytesSent,
const uint64_t& _bytesAcknowledged,
const uint64_t& _packetsSent,
const uint64_t& _bytesLost,
const uint64_t& _packetsLost,
const uint64_t& _bytesReceived,
const uint64_t& _packetsReceived,
const double& _smoothedRtt,
const double& _rttVariation,
const double& _minRtt,
const int64_t& _estimatedSendRate,
const bool& _atSendCapacity,
const WebTransportDatagramStatsData& _datagrams) :
atSendCapacity_(_atSendCapacity),
datagrams_(_datagrams),
bytesSent_(_bytesSent),
bytesAcknowledged_(_bytesAcknowledged),
packetsSent_(_packetsSent),
bytesLost_(_bytesLost),
packetsLost_(_packetsLost),
bytesReceived_(_bytesReceived),
packetsReceived_(_packetsReceived),
smoothedRtt_(_smoothedRtt),
rttVariation_(_rttVariation),
minRtt_(_minRtt),
estimatedSendRate_(_estimatedSendRate)
{
}
MOZ_IMPLICIT WebTransportStatsData(
uint64_t&& _bytesSent,
uint64_t&& _bytesAcknowledged,
uint64_t&& _packetsSent,
uint64_t&& _bytesLost,
uint64_t&& _packetsLost,
uint64_t&& _bytesReceived,
uint64_t&& _packetsReceived,
double&& _smoothedRtt,
double&& _rttVariation,
double&& _minRtt,
int64_t&& _estimatedSendRate,
bool&& _atSendCapacity,
WebTransportDatagramStatsData&& _datagrams) :
atSendCapacity_(std::move(_atSendCapacity)),
datagrams_(std::move(_datagrams)),
bytesSent_(std::move(_bytesSent)),
bytesAcknowledged_(std::move(_bytesAcknowledged)),
packetsSent_(std::move(_packetsSent)),
bytesLost_(std::move(_bytesLost)),
packetsLost_(std::move(_packetsLost)),
bytesReceived_(std::move(_bytesReceived)),
packetsReceived_(std::move(_packetsReceived)),
smoothedRtt_(std::move(_smoothedRtt)),
rttVariation_(std::move(_rttVariation)),
minRtt_(std::move(_minRtt)),
estimatedSendRate_(std::move(_estimatedSendRate))
{
}
uint64_t&
bytesSent()
{
return bytesSent_;
}
const uint64_t&
bytesSent() const
{
return bytesSent_;
}
uint64_t&
bytesAcknowledged()
{
return bytesAcknowledged_;
}
const uint64_t&
bytesAcknowledged() const
{
return bytesAcknowledged_;
}
uint64_t&
packetsSent()
{
return packetsSent_;
}
const uint64_t&
packetsSent() const
{
return packetsSent_;
}
uint64_t&
bytesLost()
{
return bytesLost_;
}
const uint64_t&
bytesLost() const
{
return bytesLost_;
}
uint64_t&
packetsLost()
{
return packetsLost_;
}
const uint64_t&
packetsLost() const
{
return packetsLost_;
}
uint64_t&
bytesReceived()
{
return bytesReceived_;
}
const uint64_t&
bytesReceived() const
{
return bytesReceived_;
}
uint64_t&
packetsReceived()
{
return packetsReceived_;
}
const uint64_t&
packetsReceived() const
{
return packetsReceived_;
}
double&
smoothedRtt()
{
return smoothedRtt_;
}
const double&
smoothedRtt() const
{
return smoothedRtt_;
}
double&
rttVariation()
{
return rttVariation_;
}
const double&
rttVariation() const
{
return rttVariation_;
}
double&
minRtt()
{
return minRtt_;
}
const double&
minRtt() const
{
return minRtt_;
}
int64_t&
estimatedSendRate()
{
return estimatedSendRate_;
}
const int64_t&
estimatedSendRate() const
{
return estimatedSendRate_;
}
bool&
atSendCapacity()
{
return atSendCapacity_;
}
const bool&
atSendCapacity() const
{
return atSendCapacity_;
}
WebTransportDatagramStatsData&
datagrams()
{
return datagrams_;
}
const WebTransportDatagramStatsData&
datagrams() const
{
return datagrams_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<bool> atSendCapacity_;
::mozilla::ipc::IPDLStructMember<WebTransportDatagramStatsData> datagrams_;
::mozilla::ipc::IPDLStructMember<uint64_t> bytesSent_;
::mozilla::ipc::IPDLStructMember<uint64_t> bytesAcknowledged_;
::mozilla::ipc::IPDLStructMember<uint64_t> packetsSent_;
::mozilla::ipc::IPDLStructMember<uint64_t> bytesLost_;
::mozilla::ipc::IPDLStructMember<uint64_t> packetsLost_;
::mozilla::ipc::IPDLStructMember<uint64_t> bytesReceived_;
::mozilla::ipc::IPDLStructMember<uint64_t> packetsReceived_;
::mozilla::ipc::IPDLStructMember<double> smoothedRtt_;
::mozilla::ipc::IPDLStructMember<double> rttVariation_;
::mozilla::ipc::IPDLStructMember<double> minRtt_;
::mozilla::ipc::IPDLStructMember<int64_t> estimatedSendRate_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebTransportStatsData>
{
typedef ::mozilla::dom::WebTransportStatsData 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 BidirectionalStreamResponse|
//
namespace mozilla {
namespace dom {
class BidirectionalStreamResponse final
{
public:
enum Type {
T__None,
Tnsresult = 1,
TBidirectionalStream,
T__Last = TBidirectionalStream
};
private:
typedef ::nsresult nsresult;
typedef ::mozilla::dom::BidirectionalStream BidirectionalStream;
typedef nsresult nsresult__tdef;
typedef BidirectionalStream BidirectionalStream__tdef;
nsresult*
ptr_nsresult()
{
return (&(mVnsresult));
}
const nsresult*
constptr_nsresult() const
{
return (&(mVnsresult));
}
BidirectionalStream*
ptr_BidirectionalStream()
{
return (&(mVBidirectionalStream));
}
const BidirectionalStream*
constptr_BidirectionalStream() const
{
return (&(mVBidirectionalStream));
}
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 BidirectionalStreamResponse() :
mType(T__None)
{
}
MOZ_IMPLICIT BidirectionalStreamResponse(const nsresult& aOther);
MOZ_IMPLICIT BidirectionalStreamResponse(nsresult&& aOther);
MOZ_IMPLICIT BidirectionalStreamResponse(const BidirectionalStream& aOther);
MOZ_IMPLICIT BidirectionalStreamResponse(BidirectionalStream&& aOther);
MOZ_IMPLICIT BidirectionalStreamResponse(const BidirectionalStreamResponse& aOther);
MOZ_IMPLICIT BidirectionalStreamResponse(BidirectionalStreamResponse&& aOther);
~BidirectionalStreamResponse();
Type
type() const
{
return mType;
}
BidirectionalStreamResponse&
operator=(const nsresult& aRhs);
BidirectionalStreamResponse&
operator=(nsresult&& aRhs);
BidirectionalStreamResponse&
operator=(const BidirectionalStream& aRhs);
BidirectionalStreamResponse&
operator=(BidirectionalStream&& aRhs);
BidirectionalStreamResponse&
operator=(const BidirectionalStreamResponse& aRhs);
BidirectionalStreamResponse&
operator=(BidirectionalStreamResponse&& aRhs);
nsresult&
get_nsresult()
{
AssertSanity(Tnsresult);
return (*(ptr_nsresult()));
}
const nsresult&
get_nsresult() const
{
AssertSanity(Tnsresult);
return (*(constptr_nsresult()));
}
operator nsresult&()
{
return get_nsresult();
}
operator const nsresult&() const
{
return get_nsresult();
}
BidirectionalStream&
get_BidirectionalStream()
{
AssertSanity(TBidirectionalStream);
return (*(ptr_BidirectionalStream()));
}
const BidirectionalStream&
get_BidirectionalStream() const
{
AssertSanity(TBidirectionalStream);
return (*(constptr_BidirectionalStream()));
}
operator BidirectionalStream&()
{
return get_BidirectionalStream();
}
operator const BidirectionalStream&() const
{
return get_BidirectionalStream();
}
private:
union {
nsresult mVnsresult;
BidirectionalStream mVBidirectionalStream;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::BidirectionalStreamResponse>
{
typedef ::mozilla::dom::BidirectionalStreamResponse 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 ResetError|
//
namespace mozilla {
namespace dom {
class ResetError 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
ResetError() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ResetError(const nsresult& _error) :
error_(_error)
{
}
MOZ_IMPLICIT ResetError(nsresult&& _error) :
error_(std::move(_error))
{
}
nsresult&
error()
{
return error_;
}
const nsresult&
error() const
{
return error_;
}
private:
::mozilla::ipc::IPDLStructMember<nsresult> error_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::ResetError>
{
typedef ::mozilla::dom::ResetError 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 StopSendingError|
//
namespace mozilla {
namespace dom {
class StopSendingError 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
StopSendingError() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT StopSendingError(const nsresult& _error) :
error_(_error)
{
}
MOZ_IMPLICIT StopSendingError(nsresult&& _error) :
error_(std::move(_error))
{
}
nsresult&
error()
{
return error_;
}
const nsresult&
error() const
{
return error_;
}
private:
::mozilla::ipc::IPDLStructMember<nsresult> error_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::StopSendingError>
{
typedef ::mozilla::dom::StopSendingError 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 StreamResetOrStopSendingError|
//
namespace mozilla {
namespace dom {
class StreamResetOrStopSendingError final
{
public:
enum Type {
T__None,
TResetError = 1,
TStopSendingError,
T__Last = TStopSendingError
};
private:
typedef ::mozilla::dom::ResetError ResetError;
typedef ::mozilla::dom::StopSendingError StopSendingError;
typedef ResetError ResetError__tdef;
typedef StopSendingError StopSendingError__tdef;
ResetError*
ptr_ResetError()
{
return (&(mVResetError));
}
const ResetError*
constptr_ResetError() const
{
return (&(mVResetError));
}
StopSendingError*
ptr_StopSendingError()
{
return (&(mVStopSendingError));
}
const StopSendingError*
constptr_StopSendingError() const
{
return (&(mVStopSendingError));
}
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 StreamResetOrStopSendingError() :
mType(T__None)
{
}
MOZ_IMPLICIT StreamResetOrStopSendingError(const ResetError& aOther);
MOZ_IMPLICIT StreamResetOrStopSendingError(ResetError&& aOther);
MOZ_IMPLICIT StreamResetOrStopSendingError(const StopSendingError& aOther);
MOZ_IMPLICIT StreamResetOrStopSendingError(StopSendingError&& aOther);
MOZ_IMPLICIT StreamResetOrStopSendingError(const StreamResetOrStopSendingError& aOther);
MOZ_IMPLICIT StreamResetOrStopSendingError(StreamResetOrStopSendingError&& aOther);
~StreamResetOrStopSendingError();
Type
type() const
{
return mType;
}
StreamResetOrStopSendingError&
operator=(const ResetError& aRhs);
StreamResetOrStopSendingError&
operator=(ResetError&& aRhs);
StreamResetOrStopSendingError&
operator=(const StopSendingError& aRhs);
StreamResetOrStopSendingError&
operator=(StopSendingError&& aRhs);
StreamResetOrStopSendingError&
operator=(const StreamResetOrStopSendingError& aRhs);
StreamResetOrStopSendingError&
operator=(StreamResetOrStopSendingError&& aRhs);
ResetError&
get_ResetError()
{
AssertSanity(TResetError);
return (*(ptr_ResetError()));
}
const ResetError&
get_ResetError() const
{
AssertSanity(TResetError);
return (*(constptr_ResetError()));
}
operator ResetError&()
{
return get_ResetError();
}
operator const ResetError&() const
{
return get_ResetError();
}
StopSendingError&
get_StopSendingError()
{
AssertSanity(TStopSendingError);
return (*(ptr_StopSendingError()));
}
const StopSendingError&
get_StopSendingError() const
{
AssertSanity(TStopSendingError);
return (*(constptr_StopSendingError()));
}
operator StopSendingError&()
{
return get_StopSendingError();
}
operator const StopSendingError&() const
{
return get_StopSendingError();
}
private:
union {
ResetError mVResetError;
StopSendingError mVStopSendingError;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::StreamResetOrStopSendingError>
{
typedef ::mozilla::dom::StreamResetOrStopSendingError paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace dom {
class PWebTransportParent;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PWebTransportChild;
} // namespace dom
} // namespace mozilla
//-----------------------------------------------------------------------------
// Code common to PWebTransportChild and PWebTransportParent
//
namespace mozilla {
namespace dom {
namespace PWebTransport {
nsresult
CreateEndpoints(
mozilla::ipc::EndpointProcInfo aParentDestInfo,
mozilla::ipc::EndpointProcInfo aChildDestInfo,
mozilla::ipc::Endpoint<::mozilla::dom::PWebTransportParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PWebTransportChild>* aChild);
nsresult
CreateEndpoints(
mozilla::ipc::Endpoint<::mozilla::dom::PWebTransportParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PWebTransportChild>* aChild);
enum MessageType {
PWebTransportStart = PWebTransportMsgStart << 16,
Msg_Close__ID,
Reply_Close__ID,
Msg_CreateUnidirectionalStream__ID,
Reply_CreateUnidirectionalStream__ID,
Msg_CreateBidirectionalStream__ID,
Reply_CreateBidirectionalStream__ID,
Msg_CreateSendGroup__ID,
Msg_OutgoingDatagram__ID,
Reply_OutgoingDatagram__ID,
Msg_GetMaxDatagramSize__ID,
Reply_GetMaxDatagramSize__ID,
Msg_GetHttpChannelID__ID,
Reply_GetHttpChannelID__ID,
Msg_SetSendOrder__ID,
Msg_SetSendGroup__ID,
Msg_ExportKeyingMaterial__ID,
Reply_ExportKeyingMaterial__ID,
Msg_GetStats__ID,
Reply_GetStats__ID,
Msg_IncomingUnidirectionalStream__ID,
Msg_IncomingBidirectionalStream__ID,
Msg_IncomingDatagram__ID,
Msg_NegotiatedProtocol__ID,
Msg_Draining__ID,
Msg_RemoteClosed__ID,
Msg_OnStreamResetOrStopSending__ID,
Msg_CloseAll__ID,
Reply_CloseAll__ID,
PWebTransportEnd
};
mozilla::UniquePtr<IPC::Message>
Msg_Close(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_Close(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_CreateUnidirectionalStream(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_CreateUnidirectionalStream(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_CreateBidirectionalStream(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_CreateBidirectionalStream(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_CreateSendGroup(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_OutgoingDatagram(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_OutgoingDatagram(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_GetMaxDatagramSize(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_GetMaxDatagramSize(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_GetHttpChannelID(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_GetHttpChannelID(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_SetSendOrder(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_SetSendGroup(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_ExportKeyingMaterial(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_ExportKeyingMaterial(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_GetStats(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_GetStats(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_IncomingUnidirectionalStream(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_IncomingBidirectionalStream(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_IncomingDatagram(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_NegotiatedProtocol(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Draining(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_RemoteClosed(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_OnStreamResetOrStopSending(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_CloseAll(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_CloseAll(IPC::Message::routeid_t routingId);
} // namespace PWebTransport
} // namespace dom
} // namespace mozilla
#endif // ifndef PWebTransport_h