webkit  2cdf99a9e3038c7e01b3c37e8ad903ecbe5eecf1
https://github.com/WebKit/webkit
Classes | Typedefs | Enumerations | Functions | Variables
cricket Namespace Reference

Classes

class  AllocateRequest
 
class  AllocationSequence
 
class  AsyncStunTCPSocket
 
class  AsyncStunTCPSocketTest
 
struct  AudioCodec
 
class  AudioContentDescription
 
struct  AudioInfo
 
class  AudioMonitor
 
struct  AudioOptions
 
struct  AudioRecvParameters
 
struct  AudioSendParameters
 
class  AudioSource
 
class  AudioSourceContext
 
struct  BandwidthEstimationInfo
 
class  BaseChannel
 
class  BasicPortAllocator
 
class  BasicPortAllocatorSession
 
class  BasicPortAllocatorTest
 
class  BasicPortAllocatorTestBase
 
class  BasicPortAllocatorTestWithRealClock
 
class  BundleFilter
 
class  Candidate
 
class  CandidatePairInterface
 
class  CandidateTranslator
 
class  ChannelManager
 
class  ChannelManagerTest
 
struct  Codec
 
class  CompositeMediaEngine
 
class  Connection
 
struct  ConnectionInfo
 
class  ConnectionMonitor
 
class  ConnectionRequest
 
class  ConnectionStatsGetter
 
class  ContentDescription
 
class  ContentGroup
 
struct  ContentInfo
 
struct  CryptoParams
 
class  CurrentSpeakerMonitor
 
class  CurrentSpeakerMonitorTest
 
struct  DataChannelErrorMessageData
 
struct  DataCodec
 
class  DataContentDescription
 
class  DataEngineInterface
 
class  DataMediaChannel
 
struct  DataMediaInfo
 
class  DataOptions
 
struct  DataReceiverInfo
 
struct  DataRecvParameters
 
struct  DataSenderInfo
 
struct  DataSendParameters
 
class  DefaultUnsignalledSsrcHandler
 
struct  Device
 
class  DtlsTransport
 
class  DtlsTransportInternal
 
class  FakeAudioReceiveStream
 
class  FakeAudioSendStream
 
class  FakeBaseEngine
 
class  FakeCall
 
class  FakeCandidatePair
 
class  FakeClockBase
 
class  FakeDataEngine
 
class  FakeDataMediaChannel
 
class  FakeDtlsTransport
 
class  FakeFlexfecReceiveStream
 
class  FakeIceTransport
 
class  FakeMediaController
 
class  FakeMediaEngine
 
class  FakeNetworkInterface
 
class  FakePortAllocator
 
class  FakePortAllocatorSession
 
class  FakeTransportController
 
class  FakeVideoCapturer
 
class  FakeVideoEngine
 
class  FakeVideoMediaChannel
 
class  FakeVideoReceiveStream
 
class  FakeVideoRenderer
 
class  FakeVideoSendStream
 
class  FakeVoiceEngine
 
class  FakeVoiceMediaChannel
 
class  FakeWebRtcVideoDecoder
 
class  FakeWebRtcVideoDecoderFactory
 
class  FakeWebRtcVideoEncoder
 
class  FakeWebRtcVideoEncoderFactory
 
class  FakeWebRtcVoiceEngine
 
class  FeedbackParam
 
class  FeedbackParams
 
struct  FourCCAliasEntry
 
struct  IceConfig
 
class  IceMessage
 
struct  IceParameters
 
class  IceTransportInternal
 
class  InternalDecoderFactory
 
class  InternalEncoderFactory
 
class  IPseudoTcpNotify
 
class  JsepTransport
 
struct  kVideoFourCCEntry
 
class  MediaChannel
 
struct  MediaConfig
 
class  MediaContentDescription
 
class  MediaContentDescriptionImpl
 
class  MediaEngineFactory
 
class  MediaEngineInterface
 
class  MediaMonitor
 
class  MediaMonitorT
 
struct  MediaReceiverInfo
 
struct  MediaSenderInfo
 
class  MediaSessionDescriptionFactory
 
struct  MediaSessionOptions
 
struct  MediaStreams
 
class  MockIceTransport
 
class  NullWebRtcVideoEngine
 
class  P2PTransportChannel
 
class  P2PTransportChannelMostLikelyToWorkFirstTest
 
class  P2PTransportChannelMultihomedTest
 
class  P2PTransportChannelPingTest
 
class  P2PTransportChannelSameNatTest
 
class  P2PTransportChannelTest
 
class  P2PTransportChannelTestBase
 
class  PayloadTypeMapper
 
class  PayloadTypeMapperTest
 
class  Port
 
class  PortAllocator
 
class  PortAllocatorSession
 
struct  PortConfiguration
 
class  PortInterface
 
struct  ProtocolAddress
 
class  ProxyConnection
 
class  PseudoTcp
 
class  QuicAlarm
 
class  QuicConnectionHelper
 
class  QuicSession
 
class  QuicTransport
 
class  QuicTransportChannel
 
struct  RawRtcpPacket
 
struct  RawRtpPacket
 
struct  ReceiveDataParams
 
class  RelayConnection
 
struct  RelayCredentials
 
class  RelayEntry
 
class  RelayMessage
 
class  RelayPort
 
class  RelayServer
 
class  RelayServerBinding
 
struct  RelayServerConfig
 
class  RelayServerConnection
 
class  ReliableQuicStream
 
class  RemoteCandidate
 
class  RtcpMuxFilter
 
struct  RtcpParameters
 
struct  RtpCapabilities
 
class  RtpClock
 
class  RtpDataChannel
 
class  RtpDataEngine
 
class  RtpDataMediaChannel
 
struct  RtpHeader
 
struct  RtpHeaderExtension
 
class  RtpHelper
 
struct  RtpParameters
 
struct  RtpSendParameters
 
struct  RtpTransceiverDirection
 
class  scoped_voe_engine
 
class  scoped_voe_ptr
 
struct  ScreenshareLayerConfig
 
class  ScreenshareLayerConfigTest
 
class  SctpFakeDataReceiver
 
class  SctpTransport
 
class  SctpTransportFactory
 
class  SctpTransportInternal
 
class  SctpTransportInternalFactory
 
class  SctpTransportTest
 
struct  SendDataParams
 
class  SessionDescription
 
class  SignalReadyToSendObserver
 
class  SignalTransportClosedObserver
 
class  SignalTransportClosedReopener
 
struct  SimulcastFormat
 
class  SrtpFilter
 
class  SrtpSession
 
class  SrtpStat
 
struct  SsrcGroup
 
struct  SsrcReceiverInfo
 
struct  SsrcSenderInfo
 
class  StreamInterfaceChannel
 
struct  StreamParams
 
struct  StreamSelector
 
class  StunAddressAttribute
 
class  StunAttribute
 
class  StunBindingRequest
 
class  StunByteStringAttribute
 
class  StunErrorCodeAttribute
 
class  StunMessage
 
class  StunPort
 
class  StunRequest
 
class  StunRequestManager
 
class  StunServer
 
class  StunTest
 
class  StunUInt16ListAttribute
 
class  StunUInt32Attribute
 
class  StunUInt64Attribute
 
class  StunXorAddressAttribute
 
class  TCPConnection
 
class  TCPPort
 
class  TestConnectionWrapper
 
class  TestRelayServer
 
class  TestStunServer
 
class  TestTurnRedirector
 
class  TestTurnServer
 
class  TestUDPPort
 
class  TransportChannelImpl
 
struct  TransportChannelStats
 
class  TransportController
 
class  TransportControllerTest
 
struct  TransportDescription
 
class  TransportDescriptionFactory
 
struct  TransportInfo
 
struct  TransportOptions
 
struct  TransportStats
 
class  TurnAllocateRequest
 
class  TurnAuthInterface
 
class  TurnChannelBindRequest
 
class  TurnCreatePermissionRequest
 
class  TurnEntry
 
class  TurnMessage
 
class  TurnPort
 
class  TurnPortTest
 
class  TurnPortTestVirtualSocketServer
 
class  TurnRedirectInterface
 
class  TurnRefreshRequest
 
class  TurnServer
 
class  TurnServerAllocation
 
class  TurnServerConnection
 
class  TurnServerConnectionTest
 
class  UDPPort
 
class  UdpTransport
 
class  UdpTransportTest
 
class  UnsignalledSsrcHandler
 
class  UsedIds
 
class  UsedPayloadTypes
 
class  UsedRtpHeaderExtensionIds
 
class  VideoAdapter
 
class  VideoAdapterTest
 
class  VideoCapturer
 
class  VideoCapturerListener
 
class  VideoChannel
 
struct  VideoChannelErrorMessageData
 
struct  VideoCodec
 
class  VideoContentDescription
 
struct  VideoDecoderParams
 
class  VideoDeviceCapturerFactory
 
struct  VideoFormat
 
struct  VideoFormatPod
 
class  VideoMediaChannel
 
class  VideoMediaErrorCatcher
 
struct  VideoMediaInfo
 
struct  VideoOptions
 
struct  VideoReceiverInfo
 
struct  VideoRecvParameters
 
struct  VideoSenderInfo
 
struct  VideoSendParameters
 
class  VoEWrapper
 
class  VoiceChannel
 
struct  VoiceChannelErrorMessageData
 
class  VoiceMediaChannel
 
struct  VoiceMediaInfo
 
struct  VoiceReceiverInfo
 
struct  VoiceSenderInfo
 
class  Vp9SettingsTest
 
class  Vp9SettingsTestWith2SL3TLFlag
 
class  Vp9SettingsTestWithFieldTrial
 
class  Vp9SettingsTestWithInvalidFlag
 
class  Vp9SettingsTestWithNoFlag
 
class  WebRtcMediaEngine2
 
class  WebRtcMediaEngineFactory
 
class  WebRtcMediaEngineNullVideo
 
class  WebRtcVcmFactory
 
class  WebRtcVcmFactoryInterface
 
class  WebRtcVideoCapturer
 
class  WebRtcVideoChannel2
 
class  WebRtcVideoChannel2BaseTest
 
class  WebRtcVideoChannel2FlexfecTest
 
class  WebRtcVideoChannel2SimulcastTest
 
class  WebRtcVideoChannel2Test
 
class  WebRtcVideoDecoderFactory
 
class  WebRtcVideoDeviceCapturerFactory
 
class  WebRtcVideoEncoderFactory
 
class  WebRtcVideoEngine2
 
class  WebRtcVideoEngine2Test
 
class  WebRtcVoiceEngine
 
class  WebRtcVoiceMediaChannel
 

Typedefs

typedef std::map< std::string, std::string > CodecParameterMap
 
typedef std::map< int, webrtc::RtpCodecParameters > RtpCodecParametersMap
 
typedef std::vector< StreamParams > StreamParamsVec
 
using VideoFrame = webrtc::VideoFrame
 
using WebRtcVideoFrame = webrtc::VideoFrame
 
typedef std::vector< Candidate > Candidates
 
typedef std::vector< ConnectionInfo > ConnectionInfos
 
typedef std::vector< TransportChannelStats > TransportChannelStatsList
 
typedef std::set< rtc::SocketAddress > ServerAddresses
 
typedef std::vector< ProtocolAddress > PortList
 
typedef std::vector< std::string > ContentNames
 
typedef std::vector< ContentInfo > ContentInfos
 
typedef std::vector< ContentGroup > ContentGroups
 
typedef std::vector< TransportInfo > TransportInfos
 
typedef MediaMonitorT< VoiceMediaChannel, VoiceMediaInfo > VoiceMediaMonitor
 
typedef MediaMonitorT< VideoMediaChannel, VideoMediaInfo > VideoMediaMonitor
 
typedef MediaMonitorT< DataMediaChannel, DataMediaInfo > DataMediaMonitor
 
typedef std::vector< AudioCodec > AudioCodecs
 
typedef std::vector< VideoCodec > VideoCodecs
 
typedef std::vector< DataCodec > DataCodecs
 
typedef std::vector< CryptoParams > CryptoParamsVec
 
typedef std::vector< webrtc::RtpExtension > RtpHeaderExtensions
 
typedef uint16_t PacketLength
 
typedef FakeTransportController TransportControllerForTest
 

Enumerations

enum  MediaType {
  MEDIA_TYPE_AUDIO, MEDIA_TYPE_VIDEO, MEDIA_TYPE_DATA, MEDIA_TYPE_AUDIO,
  MEDIA_TYPE_VIDEO, MEDIA_TYPE_DATA
}
 
enum  DataMessageType {
  DMT_NONE = 0, DMT_CONTROL = 1, DMT_BINARY = 2, DMT_TEXT = 3,
  DMT_NONE = 0, DMT_CONTROL = 1, DMT_BINARY = 2, DMT_TEXT = 3
}
 
enum  SendDataResult {
  SDR_SUCCESS, SDR_ERROR, SDR_BLOCK, SDR_SUCCESS,
  SDR_ERROR, SDR_BLOCK
}
 
enum  DataChannelType {
  DCT_NONE = 0, DCT_RTP = 1, DCT_SCTP = 2, DCT_QUIC = 3,
  DCT_NONE = 0, DCT_RTP = 1, DCT_SCTP = 2, DCT_QUIC = 3
}
 
enum  RtcpTypes {
  kRtcpTypeSR = 200, kRtcpTypeRR = 201, kRtcpTypeSDES = 202, kRtcpTypeBye = 203,
  kRtcpTypeApp = 204, kRtcpTypeRTPFB = 205, kRtcpTypePSFB = 206, kRtcpTypeSR = 200,
  kRtcpTypeRR = 201, kRtcpTypeSDES = 202, kRtcpTypeBye = 203, kRtcpTypeApp = 204,
  kRtcpTypeRTPFB = 205, kRtcpTypePSFB = 206
}
 
enum  CaptureState {
  CS_STOPPED, CS_STARTING, CS_RUNNING, CS_FAILED,
  CS_STOPPED, CS_STARTING, CS_RUNNING, CS_FAILED
}
 
enum  FourCC {
  FOURCC_I420 = FOURCC('I', '4', '2', '0'), FOURCC_I422 = FOURCC('I', '4', '2', '2'), FOURCC_I444 = FOURCC('I', '4', '4', '4'), FOURCC_I411 = FOURCC('I', '4', '1', '1'),
  FOURCC_I400 = FOURCC('I', '4', '0', '0'), FOURCC_NV21 = FOURCC('N', 'V', '2', '1'), FOURCC_NV12 = FOURCC('N', 'V', '1', '2'), FOURCC_YUY2 = FOURCC('Y', 'U', 'Y', '2'),
  FOURCC_UYVY = FOURCC('U', 'Y', 'V', 'Y'), FOURCC_M420 = FOURCC('M', '4', '2', '0'), FOURCC_ARGB = FOURCC('A', 'R', 'G', 'B'), FOURCC_BGRA = FOURCC('B', 'G', 'R', 'A'),
  FOURCC_ABGR = FOURCC('A', 'B', 'G', 'R'), FOURCC_24BG = FOURCC('2', '4', 'B', 'G'), FOURCC_RAW = FOURCC('r', 'a', 'w', ' '), FOURCC_RGBA = FOURCC('R', 'G', 'B', 'A'),
  FOURCC_RGBP = FOURCC('R', 'G', 'B', 'P'), FOURCC_RGBO = FOURCC('R', 'G', 'B', 'O'), FOURCC_R444 = FOURCC('R', '4', '4', '4'), FOURCC_RGGB = FOURCC('R', 'G', 'G', 'B'),
  FOURCC_BGGR = FOURCC('B', 'G', 'G', 'R'), FOURCC_GRBG = FOURCC('G', 'R', 'B', 'G'), FOURCC_GBRG = FOURCC('G', 'B', 'R', 'G'), FOURCC_MJPG = FOURCC('M', 'J', 'P', 'G'),
  FOURCC_YV12 = FOURCC('Y', 'V', '1', '2'), FOURCC_YV16 = FOURCC('Y', 'V', '1', '6'), FOURCC_YV24 = FOURCC('Y', 'V', '2', '4'), FOURCC_YU12 = FOURCC('Y', 'U', '1', '2'),
  FOURCC_J420 = FOURCC('J', '4', '2', '0'), FOURCC_J400 = FOURCC('J', '4', '0', '0'), FOURCC_IYUV = FOURCC('I', 'Y', 'U', 'V'), FOURCC_YU16 = FOURCC('Y', 'U', '1', '6'),
  FOURCC_YU24 = FOURCC('Y', 'U', '2', '4'), FOURCC_YUYV = FOURCC('Y', 'U', 'Y', 'V'), FOURCC_YUVS = FOURCC('y', 'u', 'v', 's'), FOURCC_HDYC = FOURCC('H', 'D', 'Y', 'C'),
  FOURCC_2VUY = FOURCC('2', 'v', 'u', 'y'), FOURCC_JPEG = FOURCC('J', 'P', 'E', 'G'), FOURCC_DMB1 = FOURCC('d', 'm', 'b', '1'), FOURCC_BA81 = FOURCC('B', 'A', '8', '1'),
  FOURCC_RGB3 = FOURCC('R', 'G', 'B', '3'), FOURCC_BGR3 = FOURCC('B', 'G', 'R', '3'), FOURCC_CM32 = FOURCC(0, 0, 0, 32), FOURCC_CM24 = FOURCC(0, 0, 0, 24),
  FOURCC_H264 = FOURCC('H', '2', '6', '4'), FOURCC_I420 = FOURCC('I', '4', '2', '0'), FOURCC_I422 = FOURCC('I', '4', '2', '2'), FOURCC_I444 = FOURCC('I', '4', '4', '4'),
  FOURCC_I411 = FOURCC('I', '4', '1', '1'), FOURCC_I400 = FOURCC('I', '4', '0', '0'), FOURCC_NV21 = FOURCC('N', 'V', '2', '1'), FOURCC_NV12 = FOURCC('N', 'V', '1', '2'),
  FOURCC_YUY2 = FOURCC('Y', 'U', 'Y', '2'), FOURCC_UYVY = FOURCC('U', 'Y', 'V', 'Y'), FOURCC_M420 = FOURCC('M', '4', '2', '0'), FOURCC_ARGB = FOURCC('A', 'R', 'G', 'B'),
  FOURCC_BGRA = FOURCC('B', 'G', 'R', 'A'), FOURCC_ABGR = FOURCC('A', 'B', 'G', 'R'), FOURCC_24BG = FOURCC('2', '4', 'B', 'G'), FOURCC_RAW = FOURCC('r', 'a', 'w', ' '),
  FOURCC_RGBA = FOURCC('R', 'G', 'B', 'A'), FOURCC_RGBP = FOURCC('R', 'G', 'B', 'P'), FOURCC_RGBO = FOURCC('R', 'G', 'B', 'O'), FOURCC_R444 = FOURCC('R', '4', '4', '4'),
  FOURCC_RGGB = FOURCC('R', 'G', 'G', 'B'), FOURCC_BGGR = FOURCC('B', 'G', 'G', 'R'), FOURCC_GRBG = FOURCC('G', 'R', 'B', 'G'), FOURCC_GBRG = FOURCC('G', 'B', 'R', 'G'),
  FOURCC_MJPG = FOURCC('M', 'J', 'P', 'G'), FOURCC_YV12 = FOURCC('Y', 'V', '1', '2'), FOURCC_YV16 = FOURCC('Y', 'V', '1', '6'), FOURCC_YV24 = FOURCC('Y', 'V', '2', '4'),
  FOURCC_YU12 = FOURCC('Y', 'U', '1', '2'), FOURCC_J420 = FOURCC('J', '4', '2', '0'), FOURCC_J400 = FOURCC('J', '4', '0', '0'), FOURCC_IYUV = FOURCC('I', 'Y', 'U', 'V'),
  FOURCC_YU16 = FOURCC('Y', 'U', '1', '6'), FOURCC_YU24 = FOURCC('Y', 'U', '2', '4'), FOURCC_YUYV = FOURCC('Y', 'U', 'Y', 'V'), FOURCC_YUVS = FOURCC('y', 'u', 'v', 's'),
  FOURCC_HDYC = FOURCC('H', 'D', 'Y', 'C'), FOURCC_2VUY = FOURCC('2', 'v', 'u', 'y'), FOURCC_JPEG = FOURCC('J', 'P', 'E', 'G'), FOURCC_DMB1 = FOURCC('d', 'm', 'b', '1'),
  FOURCC_BA81 = FOURCC('B', 'A', '8', '1'), FOURCC_RGB3 = FOURCC('R', 'G', 'B', '3'), FOURCC_BGR3 = FOURCC('B', 'G', 'R', '3'), FOURCC_CM32 = FOURCC(0, 0, 0, 32),
  FOURCC_CM24 = FOURCC(0, 0, 0, 24), FOURCC_H264 = FOURCC('H', '2', '6', '4')
}
 
enum  PacketFlags { PF_NORMAL = 0x00, PF_SRTP_BYPASS = 0x01, PF_NORMAL = 0x00, PF_SRTP_BYPASS = 0x01 }
 
enum  IceTransportState {
  IceTransportState::STATE_INIT, IceTransportState::STATE_CONNECTING, IceTransportState::STATE_COMPLETED, IceTransportState::STATE_FAILED,
  IceTransportState::STATE_INIT, IceTransportState::STATE_CONNECTING, IceTransportState::STATE_COMPLETED, IceTransportState::STATE_FAILED
}
 
enum  IceProtocolType { ICEPROTO_RFC5245, ICEPROTO_RFC5245 }
 
enum  IceConnectionState {
  kIceConnectionConnecting = 0, kIceConnectionFailed, kIceConnectionConnected, kIceConnectionCompleted,
  kIceConnectionConnecting = 0, kIceConnectionFailed, kIceConnectionConnected, kIceConnectionCompleted
}
 
enum  DtlsTransportState {
  DTLS_TRANSPORT_NEW = 0, DTLS_TRANSPORT_CONNECTING, DTLS_TRANSPORT_CONNECTED, DTLS_TRANSPORT_CLOSED,
  DTLS_TRANSPORT_FAILED, DTLS_TRANSPORT_NEW = 0, DTLS_TRANSPORT_CONNECTING, DTLS_TRANSPORT_CONNECTED,
  DTLS_TRANSPORT_CLOSED, DTLS_TRANSPORT_FAILED
}
 
enum  IceGatheringState {
  kIceGatheringNew = 0, kIceGatheringGathering, kIceGatheringComplete, kIceGatheringNew = 0,
  kIceGatheringGathering, kIceGatheringComplete
}
 
enum  ContinualGatheringPolicy {
  GATHER_ONCE = 0, GATHER_CONTINUALLY, GATHER_CONTINUALLY_AND_RECOVER, GATHER_ONCE = 0,
  GATHER_CONTINUALLY, GATHER_CONTINUALLY_AND_RECOVER
}
 
enum  NominationMode {
  NominationMode::REGULAR, NominationMode::AGGRESSIVE, NominationMode::SEMI_AGGRESSIVE, NominationMode::REGULAR,
  NominationMode::AGGRESSIVE, NominationMode::SEMI_AGGRESSIVE
}
 
enum  IceRestartState {
  IceRestartState::CONNECTING, IceRestartState::CONNECTED, IceRestartState::DISCONNECTED, IceRestartState::MAX_VALUE,
  IceRestartState::CONNECTING, IceRestartState::CONNECTED, IceRestartState::DISCONNECTED, IceRestartState::MAX_VALUE
}
 
enum  RelayType { RELAY_GTURN, RELAY_TURN, RELAY_GTURN, RELAY_TURN }
 
enum  IcePriorityValue {
  ICE_TYPE_PREFERENCE_RELAY_TLS = 0, ICE_TYPE_PREFERENCE_RELAY_TCP = 1, ICE_TYPE_PREFERENCE_RELAY_UDP = 2, ICE_TYPE_PREFERENCE_PRFLX_TCP = 80,
  ICE_TYPE_PREFERENCE_HOST_TCP = 90, ICE_TYPE_PREFERENCE_SRFLX = 100, ICE_TYPE_PREFERENCE_PRFLX = 110, ICE_TYPE_PREFERENCE_HOST = 126,
  ICE_TYPE_PREFERENCE_RELAY_TLS = 0, ICE_TYPE_PREFERENCE_RELAY_TCP = 1, ICE_TYPE_PREFERENCE_RELAY_UDP = 2, ICE_TYPE_PREFERENCE_PRFLX_TCP = 80,
  ICE_TYPE_PREFERENCE_HOST_TCP = 90, ICE_TYPE_PREFERENCE_SRFLX = 100, ICE_TYPE_PREFERENCE_PRFLX = 110, ICE_TYPE_PREFERENCE_HOST = 126
}
 
enum  IceCandidatePairState {
  IceCandidatePairState::WAITING = 0, IceCandidatePairState::IN_PROGRESS, IceCandidatePairState::SUCCEEDED, IceCandidatePairState::FAILED,
  IceCandidatePairState::WAITING = 0, IceCandidatePairState::IN_PROGRESS, IceCandidatePairState::SUCCEEDED, IceCandidatePairState::FAILED
}
 
enum  {
  PORTALLOCATOR_DISABLE_UDP = 0x01, PORTALLOCATOR_DISABLE_STUN = 0x02, PORTALLOCATOR_DISABLE_RELAY = 0x04, PORTALLOCATOR_DISABLE_TCP = 0x08,
  PORTALLOCATOR_ENABLE_IPV6 = 0x40, PORTALLOCATOR_ENABLE_SHARED_UFRAG = 0x80, PORTALLOCATOR_ENABLE_SHARED_SOCKET = 0x100, PORTALLOCATOR_ENABLE_STUN_RETRANSMIT_ATTRIBUTE = 0x200,
  PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION = 0x400, PORTALLOCATOR_DISABLE_DEFAULT_LOCAL_CANDIDATE = 0x800, PORTALLOCATOR_DISABLE_UDP_RELAY = 0x1000, PORTALLOCATOR_DISABLE_COSTLY_NETWORKS = 0x2000
}
 
enum  IceRegatheringReason {
  IceRegatheringReason::NETWORK_CHANGE, IceRegatheringReason::NETWORK_FAILURE, IceRegatheringReason::MAX_VALUE, IceRegatheringReason::NETWORK_CHANGE,
  IceRegatheringReason::NETWORK_FAILURE, IceRegatheringReason::MAX_VALUE
}
 
enum  {
  CF_NONE = 0x0, CF_HOST = 0x1, CF_REFLEXIVE = 0x2, CF_RELAY = 0x4,
  CF_ALL = 0x7
}
 
enum  TlsCertPolicy { TlsCertPolicy::TLS_CERT_POLICY_SECURE, TlsCertPolicy::TLS_CERT_POLICY_INSECURE_NO_CHECK, TlsCertPolicy::TLS_CERT_POLICY_SECURE, TlsCertPolicy::TLS_CERT_POLICY_INSECURE_NO_CHECK }
 
enum  ProtocolType {
  PROTO_UDP, PROTO_TCP, PROTO_SSLTCP, PROTO_TLS,
  PROTO_LAST = PROTO_TLS, PROTO_UDP, PROTO_TCP, PROTO_SSLTCP,
  PROTO_TLS, PROTO_LAST = PROTO_TLS
}
 
enum  ContentAction {
  CA_OFFER, CA_PRANSWER, CA_ANSWER, CA_UPDATE,
  CA_OFFER, CA_PRANSWER, CA_ANSWER, CA_UPDATE
}
 
enum  ContentSource { CS_LOCAL, CS_REMOTE, CS_LOCAL, CS_REMOTE }
 
enum  StunMessageType {
  STUN_BINDING_REQUEST = 0x0001, STUN_BINDING_INDICATION = 0x0011, STUN_BINDING_RESPONSE = 0x0101, STUN_BINDING_ERROR_RESPONSE = 0x0111,
  STUN_BINDING_REQUEST = 0x0001, STUN_BINDING_INDICATION = 0x0011, STUN_BINDING_RESPONSE = 0x0101, STUN_BINDING_ERROR_RESPONSE = 0x0111
}
 
enum  StunAttributeType {
  STUN_ATTR_MAPPED_ADDRESS = 0x0001, STUN_ATTR_USERNAME = 0x0006, STUN_ATTR_MESSAGE_INTEGRITY = 0x0008, STUN_ATTR_ERROR_CODE = 0x0009,
  STUN_ATTR_UNKNOWN_ATTRIBUTES = 0x000a, STUN_ATTR_REALM = 0x0014, STUN_ATTR_NONCE = 0x0015, STUN_ATTR_XOR_MAPPED_ADDRESS = 0x0020,
  STUN_ATTR_SOFTWARE = 0x8022, STUN_ATTR_ALTERNATE_SERVER = 0x8023, STUN_ATTR_FINGERPRINT = 0x8028, STUN_ATTR_ORIGIN = 0x802F,
  STUN_ATTR_RETRANSMIT_COUNT = 0xFF00, STUN_ATTR_MAPPED_ADDRESS = 0x0001, STUN_ATTR_USERNAME = 0x0006, STUN_ATTR_MESSAGE_INTEGRITY = 0x0008,
  STUN_ATTR_ERROR_CODE = 0x0009, STUN_ATTR_UNKNOWN_ATTRIBUTES = 0x000a, STUN_ATTR_REALM = 0x0014, STUN_ATTR_NONCE = 0x0015,
  STUN_ATTR_XOR_MAPPED_ADDRESS = 0x0020, STUN_ATTR_SOFTWARE = 0x8022, STUN_ATTR_ALTERNATE_SERVER = 0x8023, STUN_ATTR_FINGERPRINT = 0x8028,
  STUN_ATTR_ORIGIN = 0x802F, STUN_ATTR_RETRANSMIT_COUNT = 0xFF00
}
 
enum  StunAttributeValueType {
  STUN_VALUE_UNKNOWN = 0, STUN_VALUE_ADDRESS = 1, STUN_VALUE_XOR_ADDRESS = 2, STUN_VALUE_UINT32 = 3,
  STUN_VALUE_UINT64 = 4, STUN_VALUE_BYTE_STRING = 5, STUN_VALUE_ERROR_CODE = 6, STUN_VALUE_UINT16_LIST = 7,
  STUN_VALUE_UNKNOWN = 0, STUN_VALUE_ADDRESS = 1, STUN_VALUE_XOR_ADDRESS = 2, STUN_VALUE_UINT32 = 3,
  STUN_VALUE_UINT64 = 4, STUN_VALUE_BYTE_STRING = 5, STUN_VALUE_ERROR_CODE = 6, STUN_VALUE_UINT16_LIST = 7
}
 
enum  StunAddressFamily {
  STUN_ADDRESS_UNDEF = 0, STUN_ADDRESS_IPV4 = 1, STUN_ADDRESS_IPV6 = 2, STUN_ADDRESS_UNDEF = 0,
  STUN_ADDRESS_IPV4 = 1, STUN_ADDRESS_IPV6 = 2
}
 
enum  StunErrorCode {
  STUN_ERROR_TRY_ALTERNATE = 300, STUN_ERROR_BAD_REQUEST = 400, STUN_ERROR_UNAUTHORIZED = 401, STUN_ERROR_UNKNOWN_ATTRIBUTE = 420,
  STUN_ERROR_STALE_CREDENTIALS = 430, STUN_ERROR_STALE_NONCE = 438, STUN_ERROR_SERVER_ERROR = 500, STUN_ERROR_GLOBAL_FAILURE = 600,
  STUN_ERROR_TRY_ALTERNATE = 300, STUN_ERROR_BAD_REQUEST = 400, STUN_ERROR_UNAUTHORIZED = 401, STUN_ERROR_UNKNOWN_ATTRIBUTE = 420,
  STUN_ERROR_STALE_CREDENTIALS = 430, STUN_ERROR_STALE_NONCE = 438, STUN_ERROR_SERVER_ERROR = 500, STUN_ERROR_GLOBAL_FAILURE = 600
}
 
enum  RelayMessageType {
  STUN_SEND_REQUEST = 0x0004, STUN_SEND_RESPONSE = 0x0104, STUN_SEND_ERROR_RESPONSE = 0x0114, STUN_DATA_INDICATION = 0x0115,
  STUN_SEND_REQUEST = 0x0004, STUN_SEND_RESPONSE = 0x0104, STUN_SEND_ERROR_RESPONSE = 0x0114, STUN_DATA_INDICATION = 0x0115
}
 
enum  RelayAttributeType {
  STUN_ATTR_LIFETIME = 0x000d, STUN_ATTR_MAGIC_COOKIE = 0x000f, STUN_ATTR_BANDWIDTH = 0x0010, STUN_ATTR_DESTINATION_ADDRESS = 0x0011,
  STUN_ATTR_SOURCE_ADDRESS2 = 0x0012, STUN_ATTR_DATA = 0x0013, STUN_ATTR_OPTIONS = 0x8001, STUN_ATTR_LIFETIME = 0x000d,
  STUN_ATTR_MAGIC_COOKIE = 0x000f, STUN_ATTR_BANDWIDTH = 0x0010, STUN_ATTR_DESTINATION_ADDRESS = 0x0011, STUN_ATTR_SOURCE_ADDRESS2 = 0x0012,
  STUN_ATTR_DATA = 0x0013, STUN_ATTR_OPTIONS = 0x8001
}
 
enum  TurnMessageType {
  STUN_ALLOCATE_REQUEST = 0x0003, STUN_ALLOCATE_RESPONSE = 0x0103, STUN_ALLOCATE_ERROR_RESPONSE = 0x0113, TURN_REFRESH_REQUEST = 0x0004,
  TURN_REFRESH_RESPONSE = 0x0104, TURN_REFRESH_ERROR_RESPONSE = 0x0114, TURN_SEND_INDICATION = 0x0016, TURN_DATA_INDICATION = 0x0017,
  TURN_CREATE_PERMISSION_REQUEST = 0x0008, TURN_CREATE_PERMISSION_RESPONSE = 0x0108, TURN_CREATE_PERMISSION_ERROR_RESPONSE = 0x0118, TURN_CHANNEL_BIND_REQUEST = 0x0009,
  TURN_CHANNEL_BIND_RESPONSE = 0x0109, TURN_CHANNEL_BIND_ERROR_RESPONSE = 0x0119, STUN_ALLOCATE_REQUEST = 0x0003, STUN_ALLOCATE_RESPONSE = 0x0103,
  STUN_ALLOCATE_ERROR_RESPONSE = 0x0113, TURN_REFRESH_REQUEST = 0x0004, TURN_REFRESH_RESPONSE = 0x0104, TURN_REFRESH_ERROR_RESPONSE = 0x0114,
  TURN_SEND_INDICATION = 0x0016, TURN_DATA_INDICATION = 0x0017, TURN_CREATE_PERMISSION_REQUEST = 0x0008, TURN_CREATE_PERMISSION_RESPONSE = 0x0108,
  TURN_CREATE_PERMISSION_ERROR_RESPONSE = 0x0118, TURN_CHANNEL_BIND_REQUEST = 0x0009, TURN_CHANNEL_BIND_RESPONSE = 0x0109, TURN_CHANNEL_BIND_ERROR_RESPONSE = 0x0119
}
 
enum  TurnAttributeType {
  STUN_ATTR_CHANNEL_NUMBER = 0x000C, STUN_ATTR_TURN_LIFETIME = 0x000d, STUN_ATTR_XOR_PEER_ADDRESS = 0x0012, STUN_ATTR_XOR_RELAYED_ADDRESS = 0x0016,
  STUN_ATTR_EVEN_PORT = 0x0018, STUN_ATTR_REQUESTED_TRANSPORT = 0x0019, STUN_ATTR_DONT_FRAGMENT = 0x001A, STUN_ATTR_RESERVATION_TOKEN = 0x0022,
  STUN_ATTR_CHANNEL_NUMBER = 0x000C, STUN_ATTR_TURN_LIFETIME = 0x000d, STUN_ATTR_XOR_PEER_ADDRESS = 0x0012, STUN_ATTR_XOR_RELAYED_ADDRESS = 0x0016,
  STUN_ATTR_EVEN_PORT = 0x0018, STUN_ATTR_REQUESTED_TRANSPORT = 0x0019, STUN_ATTR_DONT_FRAGMENT = 0x001A, STUN_ATTR_RESERVATION_TOKEN = 0x0022
}
 
enum  TurnErrorType {
  STUN_ERROR_FORBIDDEN = 403, STUN_ERROR_ALLOCATION_MISMATCH = 437, STUN_ERROR_WRONG_CREDENTIALS = 441, STUN_ERROR_UNSUPPORTED_PROTOCOL = 442,
  STUN_ERROR_FORBIDDEN = 403, STUN_ERROR_ALLOCATION_MISMATCH = 437, STUN_ERROR_WRONG_CREDENTIALS = 441, STUN_ERROR_UNSUPPORTED_PROTOCOL = 442
}
 
enum  IceAttributeType {
  STUN_ATTR_PRIORITY = 0x0024, STUN_ATTR_USE_CANDIDATE = 0x0025, STUN_ATTR_ICE_CONTROLLED = 0x8029, STUN_ATTR_ICE_CONTROLLING = 0x802A,
  STUN_ATTR_NOMINATION = 0xC001, STUN_ATTR_NETWORK_INFO = 0xC057, STUN_ATTR_PRIORITY = 0x0024, STUN_ATTR_USE_CANDIDATE = 0x0025,
  STUN_ATTR_ICE_CONTROLLED = 0x8029, STUN_ATTR_ICE_CONTROLLING = 0x802A, STUN_ATTR_NOMINATION = 0xC001, STUN_ATTR_NETWORK_INFO = 0xC057
}
 
enum  IceErrorCode { STUN_ERROR_ROLE_CONFLICT = 487, STUN_ERROR_ROLE_CONFLICT = 487 }
 
enum  SecurePolicy {
  SEC_DISABLED, SEC_ENABLED, SEC_REQUIRED, SEC_DISABLED,
  SEC_ENABLED, SEC_REQUIRED
}
 
enum  IceRole {
  ICEROLE_CONTROLLING = 0, ICEROLE_CONTROLLED, ICEROLE_UNKNOWN, ICEROLE_CONTROLLING = 0,
  ICEROLE_CONTROLLED, ICEROLE_UNKNOWN
}
 
enum  IceMode { ICEMODE_FULL, ICEMODE_LITE, ICEMODE_FULL, ICEMODE_LITE }
 
enum  ConnectionRole {
  CONNECTIONROLE_NONE = 0, CONNECTIONROLE_ACTIVE, CONNECTIONROLE_PASSIVE, CONNECTIONROLE_ACTPASS,
  CONNECTIONROLE_HOLDCONN, CONNECTIONROLE_NONE = 0, CONNECTIONROLE_ACTIVE, CONNECTIONROLE_PASSIVE,
  CONNECTIONROLE_ACTPASS, CONNECTIONROLE_HOLDCONN
}
 
enum  SessionState {
  SessionState::GATHERING, SessionState::CLEARED, SessionState::STOPPED, SessionState::GATHERING,
  SessionState::CLEARED, SessionState::STOPPED
}
 
enum  QuicTransportState {
  QUIC_TRANSPORT_NEW = 0, QUIC_TRANSPORT_CONNECTING, QUIC_TRANSPORT_CONNECTED, QUIC_TRANSPORT_CLOSED,
  QUIC_TRANSPORT_NEW = 0, QUIC_TRANSPORT_CONNECTING, QUIC_TRANSPORT_CONNECTED, QUIC_TRANSPORT_CLOSED
}
 
enum  MediaContentDirection {
  MD_INACTIVE, MD_SENDONLY, MD_RECVONLY, MD_SENDRECV,
  MD_INACTIVE, MD_SENDONLY, MD_RECVONLY, MD_SENDRECV
}
 
enum  CryptoType {
  CT_NONE, CT_SDES, CT_DTLS, CT_NONE,
  CT_SDES, CT_DTLS
}
 
enum  MediaType {
  MEDIA_TYPE_AUDIO, MEDIA_TYPE_VIDEO, MEDIA_TYPE_DATA, MEDIA_TYPE_AUDIO,
  MEDIA_TYPE_VIDEO, MEDIA_TYPE_DATA
}
 
enum  DataMessageType {
  DMT_NONE = 0, DMT_CONTROL = 1, DMT_BINARY = 2, DMT_TEXT = 3,
  DMT_NONE = 0, DMT_CONTROL = 1, DMT_BINARY = 2, DMT_TEXT = 3
}
 
enum  SendDataResult {
  SDR_SUCCESS, SDR_ERROR, SDR_BLOCK, SDR_SUCCESS,
  SDR_ERROR, SDR_BLOCK
}
 
enum  DataChannelType {
  DCT_NONE = 0, DCT_RTP = 1, DCT_SCTP = 2, DCT_QUIC = 3,
  DCT_NONE = 0, DCT_RTP = 1, DCT_SCTP = 2, DCT_QUIC = 3
}
 
enum  RtcpTypes {
  kRtcpTypeSR = 200, kRtcpTypeRR = 201, kRtcpTypeSDES = 202, kRtcpTypeBye = 203,
  kRtcpTypeApp = 204, kRtcpTypeRTPFB = 205, kRtcpTypePSFB = 206, kRtcpTypeSR = 200,
  kRtcpTypeRR = 201, kRtcpTypeSDES = 202, kRtcpTypeBye = 203, kRtcpTypeApp = 204,
  kRtcpTypeRTPFB = 205, kRtcpTypePSFB = 206
}
 
enum  CaptureState {
  CS_STOPPED, CS_STARTING, CS_RUNNING, CS_FAILED,
  CS_STOPPED, CS_STARTING, CS_RUNNING, CS_FAILED
}
 
enum  FourCC {
  FOURCC_I420 = FOURCC('I', '4', '2', '0'), FOURCC_I422 = FOURCC('I', '4', '2', '2'), FOURCC_I444 = FOURCC('I', '4', '4', '4'), FOURCC_I411 = FOURCC('I', '4', '1', '1'),
  FOURCC_I400 = FOURCC('I', '4', '0', '0'), FOURCC_NV21 = FOURCC('N', 'V', '2', '1'), FOURCC_NV12 = FOURCC('N', 'V', '1', '2'), FOURCC_YUY2 = FOURCC('Y', 'U', 'Y', '2'),
  FOURCC_UYVY = FOURCC('U', 'Y', 'V', 'Y'), FOURCC_M420 = FOURCC('M', '4', '2', '0'), FOURCC_ARGB = FOURCC('A', 'R', 'G', 'B'), FOURCC_BGRA = FOURCC('B', 'G', 'R', 'A'),
  FOURCC_ABGR = FOURCC('A', 'B', 'G', 'R'), FOURCC_24BG = FOURCC('2', '4', 'B', 'G'), FOURCC_RAW = FOURCC('r', 'a', 'w', ' '), FOURCC_RGBA = FOURCC('R', 'G', 'B', 'A'),
  FOURCC_RGBP = FOURCC('R', 'G', 'B', 'P'), FOURCC_RGBO = FOURCC('R', 'G', 'B', 'O'), FOURCC_R444 = FOURCC('R', '4', '4', '4'), FOURCC_RGGB = FOURCC('R', 'G', 'G', 'B'),
  FOURCC_BGGR = FOURCC('B', 'G', 'G', 'R'), FOURCC_GRBG = FOURCC('G', 'R', 'B', 'G'), FOURCC_GBRG = FOURCC('G', 'B', 'R', 'G'), FOURCC_MJPG = FOURCC('M', 'J', 'P', 'G'),
  FOURCC_YV12 = FOURCC('Y', 'V', '1', '2'), FOURCC_YV16 = FOURCC('Y', 'V', '1', '6'), FOURCC_YV24 = FOURCC('Y', 'V', '2', '4'), FOURCC_YU12 = FOURCC('Y', 'U', '1', '2'),
  FOURCC_J420 = FOURCC('J', '4', '2', '0'), FOURCC_J400 = FOURCC('J', '4', '0', '0'), FOURCC_IYUV = FOURCC('I', 'Y', 'U', 'V'), FOURCC_YU16 = FOURCC('Y', 'U', '1', '6'),
  FOURCC_YU24 = FOURCC('Y', 'U', '2', '4'), FOURCC_YUYV = FOURCC('Y', 'U', 'Y', 'V'), FOURCC_YUVS = FOURCC('y', 'u', 'v', 's'), FOURCC_HDYC = FOURCC('H', 'D', 'Y', 'C'),
  FOURCC_2VUY = FOURCC('2', 'v', 'u', 'y'), FOURCC_JPEG = FOURCC('J', 'P', 'E', 'G'), FOURCC_DMB1 = FOURCC('d', 'm', 'b', '1'), FOURCC_BA81 = FOURCC('B', 'A', '8', '1'),
  FOURCC_RGB3 = FOURCC('R', 'G', 'B', '3'), FOURCC_BGR3 = FOURCC('B', 'G', 'R', '3'), FOURCC_CM32 = FOURCC(0, 0, 0, 32), FOURCC_CM24 = FOURCC(0, 0, 0, 24),
  FOURCC_H264 = FOURCC('H', '2', '6', '4'), FOURCC_I420 = FOURCC('I', '4', '2', '0'), FOURCC_I422 = FOURCC('I', '4', '2', '2'), FOURCC_I444 = FOURCC('I', '4', '4', '4'),
  FOURCC_I411 = FOURCC('I', '4', '1', '1'), FOURCC_I400 = FOURCC('I', '4', '0', '0'), FOURCC_NV21 = FOURCC('N', 'V', '2', '1'), FOURCC_NV12 = FOURCC('N', 'V', '1', '2'),
  FOURCC_YUY2 = FOURCC('Y', 'U', 'Y', '2'), FOURCC_UYVY = FOURCC('U', 'Y', 'V', 'Y'), FOURCC_M420 = FOURCC('M', '4', '2', '0'), FOURCC_ARGB = FOURCC('A', 'R', 'G', 'B'),
  FOURCC_BGRA = FOURCC('B', 'G', 'R', 'A'), FOURCC_ABGR = FOURCC('A', 'B', 'G', 'R'), FOURCC_24BG = FOURCC('2', '4', 'B', 'G'), FOURCC_RAW = FOURCC('r', 'a', 'w', ' '),
  FOURCC_RGBA = FOURCC('R', 'G', 'B', 'A'), FOURCC_RGBP = FOURCC('R', 'G', 'B', 'P'), FOURCC_RGBO = FOURCC('R', 'G', 'B', 'O'), FOURCC_R444 = FOURCC('R', '4', '4', '4'),
  FOURCC_RGGB = FOURCC('R', 'G', 'G', 'B'), FOURCC_BGGR = FOURCC('B', 'G', 'G', 'R'), FOURCC_GRBG = FOURCC('G', 'R', 'B', 'G'), FOURCC_GBRG = FOURCC('G', 'B', 'R', 'G'),
  FOURCC_MJPG = FOURCC('M', 'J', 'P', 'G'), FOURCC_YV12 = FOURCC('Y', 'V', '1', '2'), FOURCC_YV16 = FOURCC('Y', 'V', '1', '6'), FOURCC_YV24 = FOURCC('Y', 'V', '2', '4'),
  FOURCC_YU12 = FOURCC('Y', 'U', '1', '2'), FOURCC_J420 = FOURCC('J', '4', '2', '0'), FOURCC_J400 = FOURCC('J', '4', '0', '0'), FOURCC_IYUV = FOURCC('I', 'Y', 'U', 'V'),
  FOURCC_YU16 = FOURCC('Y', 'U', '1', '6'), FOURCC_YU24 = FOURCC('Y', 'U', '2', '4'), FOURCC_YUYV = FOURCC('Y', 'U', 'Y', 'V'), FOURCC_YUVS = FOURCC('y', 'u', 'v', 's'),
  FOURCC_HDYC = FOURCC('H', 'D', 'Y', 'C'), FOURCC_2VUY = FOURCC('2', 'v', 'u', 'y'), FOURCC_JPEG = FOURCC('J', 'P', 'E', 'G'), FOURCC_DMB1 = FOURCC('d', 'm', 'b', '1'),
  FOURCC_BA81 = FOURCC('B', 'A', '8', '1'), FOURCC_RGB3 = FOURCC('R', 'G', 'B', '3'), FOURCC_BGR3 = FOURCC('B', 'G', 'R', '3'), FOURCC_CM32 = FOURCC(0, 0, 0, 32),
  FOURCC_CM24 = FOURCC(0, 0, 0, 24), FOURCC_H264 = FOURCC('H', '2', '6', '4')
}
 
enum  PacketFlags { PF_NORMAL = 0x00, PF_SRTP_BYPASS = 0x01, PF_NORMAL = 0x00, PF_SRTP_BYPASS = 0x01 }
 
enum  IceTransportState {
  IceTransportState::STATE_INIT, IceTransportState::STATE_CONNECTING, IceTransportState::STATE_COMPLETED, IceTransportState::STATE_FAILED,
  IceTransportState::STATE_INIT, IceTransportState::STATE_CONNECTING, IceTransportState::STATE_COMPLETED, IceTransportState::STATE_FAILED
}
 
enum  IceProtocolType { ICEPROTO_RFC5245, ICEPROTO_RFC5245 }
 
enum  IceConnectionState {
  kIceConnectionConnecting = 0, kIceConnectionFailed, kIceConnectionConnected, kIceConnectionCompleted,
  kIceConnectionConnecting = 0, kIceConnectionFailed, kIceConnectionConnected, kIceConnectionCompleted
}
 
enum  DtlsTransportState {
  DTLS_TRANSPORT_NEW = 0, DTLS_TRANSPORT_CONNECTING, DTLS_TRANSPORT_CONNECTED, DTLS_TRANSPORT_CLOSED,
  DTLS_TRANSPORT_FAILED, DTLS_TRANSPORT_NEW = 0, DTLS_TRANSPORT_CONNECTING, DTLS_TRANSPORT_CONNECTED,
  DTLS_TRANSPORT_CLOSED, DTLS_TRANSPORT_FAILED
}
 
enum  IceGatheringState {
  kIceGatheringNew = 0, kIceGatheringGathering, kIceGatheringComplete, kIceGatheringNew = 0,
  kIceGatheringGathering, kIceGatheringComplete
}
 
enum  ContinualGatheringPolicy {
  GATHER_ONCE = 0, GATHER_CONTINUALLY, GATHER_CONTINUALLY_AND_RECOVER, GATHER_ONCE = 0,
  GATHER_CONTINUALLY, GATHER_CONTINUALLY_AND_RECOVER
}
 
enum  NominationMode {
  NominationMode::REGULAR, NominationMode::AGGRESSIVE, NominationMode::SEMI_AGGRESSIVE, NominationMode::REGULAR,
  NominationMode::AGGRESSIVE, NominationMode::SEMI_AGGRESSIVE
}
 
enum  IceRestartState {
  IceRestartState::CONNECTING, IceRestartState::CONNECTED, IceRestartState::DISCONNECTED, IceRestartState::MAX_VALUE,
  IceRestartState::CONNECTING, IceRestartState::CONNECTED, IceRestartState::DISCONNECTED, IceRestartState::MAX_VALUE
}
 
enum  RelayType { RELAY_GTURN, RELAY_TURN, RELAY_GTURN, RELAY_TURN }
 
enum  IcePriorityValue {
  ICE_TYPE_PREFERENCE_RELAY_TLS = 0, ICE_TYPE_PREFERENCE_RELAY_TCP = 1, ICE_TYPE_PREFERENCE_RELAY_UDP = 2, ICE_TYPE_PREFERENCE_PRFLX_TCP = 80,
  ICE_TYPE_PREFERENCE_HOST_TCP = 90, ICE_TYPE_PREFERENCE_SRFLX = 100, ICE_TYPE_PREFERENCE_PRFLX = 110, ICE_TYPE_PREFERENCE_HOST = 126,
  ICE_TYPE_PREFERENCE_RELAY_TLS = 0, ICE_TYPE_PREFERENCE_RELAY_TCP = 1, ICE_TYPE_PREFERENCE_RELAY_UDP = 2, ICE_TYPE_PREFERENCE_PRFLX_TCP = 80,
  ICE_TYPE_PREFERENCE_HOST_TCP = 90, ICE_TYPE_PREFERENCE_SRFLX = 100, ICE_TYPE_PREFERENCE_PRFLX = 110, ICE_TYPE_PREFERENCE_HOST = 126
}
 
enum  IceCandidatePairState {
  IceCandidatePairState::WAITING = 0, IceCandidatePairState::IN_PROGRESS, IceCandidatePairState::SUCCEEDED, IceCandidatePairState::FAILED,
  IceCandidatePairState::WAITING = 0, IceCandidatePairState::IN_PROGRESS, IceCandidatePairState::SUCCEEDED, IceCandidatePairState::FAILED
}
 
enum  {
  PORTALLOCATOR_DISABLE_UDP = 0x01, PORTALLOCATOR_DISABLE_STUN = 0x02, PORTALLOCATOR_DISABLE_RELAY = 0x04, PORTALLOCATOR_DISABLE_TCP = 0x08,
  PORTALLOCATOR_ENABLE_IPV6 = 0x40, PORTALLOCATOR_ENABLE_SHARED_UFRAG = 0x80, PORTALLOCATOR_ENABLE_SHARED_SOCKET = 0x100, PORTALLOCATOR_ENABLE_STUN_RETRANSMIT_ATTRIBUTE = 0x200,
  PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION = 0x400, PORTALLOCATOR_DISABLE_DEFAULT_LOCAL_CANDIDATE = 0x800, PORTALLOCATOR_DISABLE_UDP_RELAY = 0x1000, PORTALLOCATOR_DISABLE_COSTLY_NETWORKS = 0x2000
}
 
enum  IceRegatheringReason {
  IceRegatheringReason::NETWORK_CHANGE, IceRegatheringReason::NETWORK_FAILURE, IceRegatheringReason::MAX_VALUE, IceRegatheringReason::NETWORK_CHANGE,
  IceRegatheringReason::NETWORK_FAILURE, IceRegatheringReason::MAX_VALUE
}
 
enum  {
  CF_NONE = 0x0, CF_HOST = 0x1, CF_REFLEXIVE = 0x2, CF_RELAY = 0x4,
  CF_ALL = 0x7
}
 
enum  TlsCertPolicy { TlsCertPolicy::TLS_CERT_POLICY_SECURE, TlsCertPolicy::TLS_CERT_POLICY_INSECURE_NO_CHECK, TlsCertPolicy::TLS_CERT_POLICY_SECURE, TlsCertPolicy::TLS_CERT_POLICY_INSECURE_NO_CHECK }
 
enum  ProtocolType {
  PROTO_UDP, PROTO_TCP, PROTO_SSLTCP, PROTO_TLS,
  PROTO_LAST = PROTO_TLS, PROTO_UDP, PROTO_TCP, PROTO_SSLTCP,
  PROTO_TLS, PROTO_LAST = PROTO_TLS
}
 
enum  ContentAction {
  CA_OFFER, CA_PRANSWER, CA_ANSWER, CA_UPDATE,
  CA_OFFER, CA_PRANSWER, CA_ANSWER, CA_UPDATE
}
 
enum  ContentSource { CS_LOCAL, CS_REMOTE, CS_LOCAL, CS_REMOTE }
 
enum  StunMessageType {
  STUN_BINDING_REQUEST = 0x0001, STUN_BINDING_INDICATION = 0x0011, STUN_BINDING_RESPONSE = 0x0101, STUN_BINDING_ERROR_RESPONSE = 0x0111,
  STUN_BINDING_REQUEST = 0x0001, STUN_BINDING_INDICATION = 0x0011, STUN_BINDING_RESPONSE = 0x0101, STUN_BINDING_ERROR_RESPONSE = 0x0111
}
 
enum  StunAttributeType {
  STUN_ATTR_MAPPED_ADDRESS = 0x0001, STUN_ATTR_USERNAME = 0x0006, STUN_ATTR_MESSAGE_INTEGRITY = 0x0008, STUN_ATTR_ERROR_CODE = 0x0009,
  STUN_ATTR_UNKNOWN_ATTRIBUTES = 0x000a, STUN_ATTR_REALM = 0x0014, STUN_ATTR_NONCE = 0x0015, STUN_ATTR_XOR_MAPPED_ADDRESS = 0x0020,
  STUN_ATTR_SOFTWARE = 0x8022, STUN_ATTR_ALTERNATE_SERVER = 0x8023, STUN_ATTR_FINGERPRINT = 0x8028, STUN_ATTR_ORIGIN = 0x802F,
  STUN_ATTR_RETRANSMIT_COUNT = 0xFF00, STUN_ATTR_MAPPED_ADDRESS = 0x0001, STUN_ATTR_USERNAME = 0x0006, STUN_ATTR_MESSAGE_INTEGRITY = 0x0008,
  STUN_ATTR_ERROR_CODE = 0x0009, STUN_ATTR_UNKNOWN_ATTRIBUTES = 0x000a, STUN_ATTR_REALM = 0x0014, STUN_ATTR_NONCE = 0x0015,
  STUN_ATTR_XOR_MAPPED_ADDRESS = 0x0020, STUN_ATTR_SOFTWARE = 0x8022, STUN_ATTR_ALTERNATE_SERVER = 0x8023, STUN_ATTR_FINGERPRINT = 0x8028,
  STUN_ATTR_ORIGIN = 0x802F, STUN_ATTR_RETRANSMIT_COUNT = 0xFF00
}
 
enum  StunAttributeValueType {
  STUN_VALUE_UNKNOWN = 0, STUN_VALUE_ADDRESS = 1, STUN_VALUE_XOR_ADDRESS = 2, STUN_VALUE_UINT32 = 3,
  STUN_VALUE_UINT64 = 4, STUN_VALUE_BYTE_STRING = 5, STUN_VALUE_ERROR_CODE = 6, STUN_VALUE_UINT16_LIST = 7,
  STUN_VALUE_UNKNOWN = 0, STUN_VALUE_ADDRESS = 1, STUN_VALUE_XOR_ADDRESS = 2, STUN_VALUE_UINT32 = 3,
  STUN_VALUE_UINT64 = 4, STUN_VALUE_BYTE_STRING = 5, STUN_VALUE_ERROR_CODE = 6, STUN_VALUE_UINT16_LIST = 7
}
 
enum  StunAddressFamily {
  STUN_ADDRESS_UNDEF = 0, STUN_ADDRESS_IPV4 = 1, STUN_ADDRESS_IPV6 = 2, STUN_ADDRESS_UNDEF = 0,
  STUN_ADDRESS_IPV4 = 1, STUN_ADDRESS_IPV6 = 2
}
 
enum  StunErrorCode {
  STUN_ERROR_TRY_ALTERNATE = 300, STUN_ERROR_BAD_REQUEST = 400, STUN_ERROR_UNAUTHORIZED = 401, STUN_ERROR_UNKNOWN_ATTRIBUTE = 420,
  STUN_ERROR_STALE_CREDENTIALS = 430, STUN_ERROR_STALE_NONCE = 438, STUN_ERROR_SERVER_ERROR = 500, STUN_ERROR_GLOBAL_FAILURE = 600,
  STUN_ERROR_TRY_ALTERNATE = 300, STUN_ERROR_BAD_REQUEST = 400, STUN_ERROR_UNAUTHORIZED = 401, STUN_ERROR_UNKNOWN_ATTRIBUTE = 420,
  STUN_ERROR_STALE_CREDENTIALS = 430, STUN_ERROR_STALE_NONCE = 438, STUN_ERROR_SERVER_ERROR = 500, STUN_ERROR_GLOBAL_FAILURE = 600
}
 
enum  RelayMessageType {
  STUN_SEND_REQUEST = 0x0004, STUN_SEND_RESPONSE = 0x0104, STUN_SEND_ERROR_RESPONSE = 0x0114, STUN_DATA_INDICATION = 0x0115,
  STUN_SEND_REQUEST = 0x0004, STUN_SEND_RESPONSE = 0x0104, STUN_SEND_ERROR_RESPONSE = 0x0114, STUN_DATA_INDICATION = 0x0115
}
 
enum  RelayAttributeType {
  STUN_ATTR_LIFETIME = 0x000d, STUN_ATTR_MAGIC_COOKIE = 0x000f, STUN_ATTR_BANDWIDTH = 0x0010, STUN_ATTR_DESTINATION_ADDRESS = 0x0011,
  STUN_ATTR_SOURCE_ADDRESS2 = 0x0012, STUN_ATTR_DATA = 0x0013, STUN_ATTR_OPTIONS = 0x8001, STUN_ATTR_LIFETIME = 0x000d,
  STUN_ATTR_MAGIC_COOKIE = 0x000f, STUN_ATTR_BANDWIDTH = 0x0010, STUN_ATTR_DESTINATION_ADDRESS = 0x0011, STUN_ATTR_SOURCE_ADDRESS2 = 0x0012,
  STUN_ATTR_DATA = 0x0013, STUN_ATTR_OPTIONS = 0x8001
}
 
enum  TurnMessageType {
  STUN_ALLOCATE_REQUEST = 0x0003, STUN_ALLOCATE_RESPONSE = 0x0103, STUN_ALLOCATE_ERROR_RESPONSE = 0x0113, TURN_REFRESH_REQUEST = 0x0004,
  TURN_REFRESH_RESPONSE = 0x0104, TURN_REFRESH_ERROR_RESPONSE = 0x0114, TURN_SEND_INDICATION = 0x0016, TURN_DATA_INDICATION = 0x0017,
  TURN_CREATE_PERMISSION_REQUEST = 0x0008, TURN_CREATE_PERMISSION_RESPONSE = 0x0108, TURN_CREATE_PERMISSION_ERROR_RESPONSE = 0x0118, TURN_CHANNEL_BIND_REQUEST = 0x0009,
  TURN_CHANNEL_BIND_RESPONSE = 0x0109, TURN_CHANNEL_BIND_ERROR_RESPONSE = 0x0119, STUN_ALLOCATE_REQUEST = 0x0003, STUN_ALLOCATE_RESPONSE = 0x0103,
  STUN_ALLOCATE_ERROR_RESPONSE = 0x0113, TURN_REFRESH_REQUEST = 0x0004, TURN_REFRESH_RESPONSE = 0x0104, TURN_REFRESH_ERROR_RESPONSE = 0x0114,
  TURN_SEND_INDICATION = 0x0016, TURN_DATA_INDICATION = 0x0017, TURN_CREATE_PERMISSION_REQUEST = 0x0008, TURN_CREATE_PERMISSION_RESPONSE = 0x0108,
  TURN_CREATE_PERMISSION_ERROR_RESPONSE = 0x0118, TURN_CHANNEL_BIND_REQUEST = 0x0009, TURN_CHANNEL_BIND_RESPONSE = 0x0109, TURN_CHANNEL_BIND_ERROR_RESPONSE = 0x0119
}
 
enum  TurnAttributeType {
  STUN_ATTR_CHANNEL_NUMBER = 0x000C, STUN_ATTR_TURN_LIFETIME = 0x000d, STUN_ATTR_XOR_PEER_ADDRESS = 0x0012, STUN_ATTR_XOR_RELAYED_ADDRESS = 0x0016,
  STUN_ATTR_EVEN_PORT = 0x0018, STUN_ATTR_REQUESTED_TRANSPORT = 0x0019, STUN_ATTR_DONT_FRAGMENT = 0x001A, STUN_ATTR_RESERVATION_TOKEN = 0x0022,
  STUN_ATTR_CHANNEL_NUMBER = 0x000C, STUN_ATTR_TURN_LIFETIME = 0x000d, STUN_ATTR_XOR_PEER_ADDRESS = 0x0012, STUN_ATTR_XOR_RELAYED_ADDRESS = 0x0016,
  STUN_ATTR_EVEN_PORT = 0x0018, STUN_ATTR_REQUESTED_TRANSPORT = 0x0019, STUN_ATTR_DONT_FRAGMENT = 0x001A, STUN_ATTR_RESERVATION_TOKEN = 0x0022
}
 
enum  TurnErrorType {
  STUN_ERROR_FORBIDDEN = 403, STUN_ERROR_ALLOCATION_MISMATCH = 437, STUN_ERROR_WRONG_CREDENTIALS = 441, STUN_ERROR_UNSUPPORTED_PROTOCOL = 442,
  STUN_ERROR_FORBIDDEN = 403, STUN_ERROR_ALLOCATION_MISMATCH = 437, STUN_ERROR_WRONG_CREDENTIALS = 441, STUN_ERROR_UNSUPPORTED_PROTOCOL = 442
}
 
enum  IceAttributeType {
  STUN_ATTR_PRIORITY = 0x0024, STUN_ATTR_USE_CANDIDATE = 0x0025, STUN_ATTR_ICE_CONTROLLED = 0x8029, STUN_ATTR_ICE_CONTROLLING = 0x802A,
  STUN_ATTR_NOMINATION = 0xC001, STUN_ATTR_NETWORK_INFO = 0xC057, STUN_ATTR_PRIORITY = 0x0024, STUN_ATTR_USE_CANDIDATE = 0x0025,
  STUN_ATTR_ICE_CONTROLLED = 0x8029, STUN_ATTR_ICE_CONTROLLING = 0x802A, STUN_ATTR_NOMINATION = 0xC001, STUN_ATTR_NETWORK_INFO = 0xC057
}
 
enum  IceErrorCode { STUN_ERROR_ROLE_CONFLICT = 487, STUN_ERROR_ROLE_CONFLICT = 487 }
 
enum  SecurePolicy {
  SEC_DISABLED, SEC_ENABLED, SEC_REQUIRED, SEC_DISABLED,
  SEC_ENABLED, SEC_REQUIRED
}
 
enum  IceRole {
  ICEROLE_CONTROLLING = 0, ICEROLE_CONTROLLED, ICEROLE_UNKNOWN, ICEROLE_CONTROLLING = 0,
  ICEROLE_CONTROLLED, ICEROLE_UNKNOWN
}
 
enum  IceMode { ICEMODE_FULL, ICEMODE_LITE, ICEMODE_FULL, ICEMODE_LITE }
 
enum  ConnectionRole {
  CONNECTIONROLE_NONE = 0, CONNECTIONROLE_ACTIVE, CONNECTIONROLE_PASSIVE, CONNECTIONROLE_ACTPASS,
  CONNECTIONROLE_HOLDCONN, CONNECTIONROLE_NONE = 0, CONNECTIONROLE_ACTIVE, CONNECTIONROLE_PASSIVE,
  CONNECTIONROLE_ACTPASS, CONNECTIONROLE_HOLDCONN
}
 
enum  { MSG_ALLOCATION_TIMEOUT }
 
enum  SessionState {
  SessionState::GATHERING, SessionState::CLEARED, SessionState::STOPPED, SessionState::GATHERING,
  SessionState::CLEARED, SessionState::STOPPED
}
 
enum  { MSG_MONITOR_POLL = 1, MSG_MONITOR_START = 2, MSG_MONITOR_STOP = 3, MSG_MONITOR_SIGNAL = 4 }
 
enum  QuicTransportState {
  QUIC_TRANSPORT_NEW = 0, QUIC_TRANSPORT_CONNECTING, QUIC_TRANSPORT_CONNECTED, QUIC_TRANSPORT_CLOSED,
  QUIC_TRANSPORT_NEW = 0, QUIC_TRANSPORT_CONNECTING, QUIC_TRANSPORT_CONNECTED, QUIC_TRANSPORT_CLOSED
}
 
enum  {
  MSG_EARLYMEDIATIMEOUT = 1, MSG_SEND_RTP_PACKET, MSG_SEND_RTCP_PACKET, MSG_CHANNEL_ERROR,
  MSG_READYTOSENDDATA, MSG_DATARECEIVED, MSG_FIRSTPACKETRECEIVED
}
 
enum  { MSG_MONITOR_POLL = 1, MSG_MONITOR_START = 2, MSG_MONITOR_STOP = 3, MSG_MONITOR_SIGNAL = 4 }
 
enum  MediaContentDirection {
  MD_INACTIVE, MD_SENDONLY, MD_RECVONLY, MD_SENDRECV,
  MD_INACTIVE, MD_SENDONLY, MD_RECVONLY, MD_SENDRECV
}
 
enum  CryptoType {
  CT_NONE, CT_SDES, CT_DTLS, CT_NONE,
  CT_SDES, CT_DTLS
}
 

Functions

std::string MediaTypeToString (MediaType type)
 
MediaType MediaTypeFromString (const std::string &type_str)
 
std::ostream & operator<< (std::ostream &os, const AudioCodec &ac)
 
template<class Codec >
const Codec * FindCodecById (const std::vector< Codec > &codecs, int payload_type)
 
bool CodecNamesEq (const std::string &name1, const std::string &name2)
 
bool CodecNamesEq (const char *name1, const char *name2)
 
bool HasNack (const Codec &codec)
 
bool HasRemb (const Codec &codec)
 
bool HasTransportCc (const Codec &codec)
 
const VideoCodec * FindMatchingCodec (const std::vector< VideoCodec > &supported_codecs, const VideoCodec &codec)
 
bool CompareDtmfInfo (const FakeVoiceMediaChannel::DtmfInfo &info, uint32_t ssrc, int event_code, int duration)
 
webrtc::RtpParameters CreateRtpParametersWithOneEncoding ()
 
bool GetRtpPayloadType (const void *data, size_t len, int *value)
 
bool GetRtpSeqNum (const void *data, size_t len, int *value)
 
bool GetRtpTimestamp (const void *data, size_t len, uint32_t *value)
 
bool GetRtpSsrc (const void *data, size_t len, uint32_t *value)
 
bool GetRtpHeaderLen (const void *data, size_t len, size_t *value)
 
bool GetRtcpType (const void *data, size_t len, int *value)
 
bool GetRtcpSsrc (const void *data, size_t len, uint32_t *value)
 
bool GetRtpHeader (const void *data, size_t len, RtpHeader *header)
 
bool SetRtpSsrc (void *data, size_t len, uint32_t value)
 
bool SetRtpHeader (void *data, size_t len, const RtpHeader &header)
 
bool IsRtpPacket (const void *data, size_t len)
 
bool IsValidRtpPayloadType (int payload_type)
 
bool ValidateRtpHeader (const uint8_t *rtp, size_t length, size_t *header_length)
 
bool UpdateRtpAbsSendTimeExtension (uint8_t *rtp, size_t length, int extension_id, uint64_t time_us)
 
bool ApplyPacketOptions (uint8_t *data, size_t length, const rtc::PacketTimeUpdateParams &packet_time_params, uint64_t time_us)
 
template<class Condition >
const StreamParams * GetStream (const StreamParamsVec &streams, Condition condition)
 
const StreamParams * GetStreamBySsrc (const StreamParamsVec &streams, uint32_t ssrc)
 
const StreamParams * GetStreamByIds (const StreamParamsVec &streams, const std::string &groupid, const std::string &id)
 
const StreamParams * GetStream (const StreamParamsVec &streams, const StreamSelector &selector)
 
template<class Condition >
bool RemoveStream (StreamParamsVec *streams, Condition condition)
 
bool RemoveStream (StreamParamsVec *streams, const StreamSelector &selector)
 
bool RemoveStreamBySsrc (StreamParamsVec *streams, uint32_t ssrc)
 
bool RemoveStreamByIds (StreamParamsVec *streams, const std::string &groupid, const std::string &id)
 
bool IsOneSsrcStream (const StreamParams &sp)
 
bool IsSimulcastStream (const StreamParams &sp)
 
template<class T >
std::vector< T > MakeVector (const T a[], size_t s)
 
template<class C >
bool ContainsMatchingCodec (const std::vector< C > &codecs, const C &codec)
 
cricket::StreamParams CreateSimStreamParams (const std::string &cname, const std::vector< uint32_t > &ssrcs)
 
cricket::StreamParams CreateSimWithRtxStreamParams (const std::string &cname, const std::vector< uint32_t > &ssrcs, const std::vector< uint32_t > &rtx_ssrcs)
 
cricket::StreamParams CreatePrimaryWithFecFrStreamParams (const std::string &cname, uint32_t primary_ssrc, uint32_t flexfec_ssrc)
 
bool UnwrapTurnPacket (const uint8_t *packet, size_t packet_size, size_t *content_position, size_t *content_size)
 
uint32_t CanonicalFourCC (uint32_t fourcc)
 
std::string GetFourccName (uint32_t fourcc)
 
webrtc::SdpAudioFormat AudioCodecToSdpAudioFormat (const AudioCodec &ac)
 
int GetTotalMaxBitrateBps (const std::vector< webrtc::VideoStream > &streams)
 
void GetSimulcastSsrcs (const StreamParams &sp, std::vector< uint32_t > *ssrcs)
 
std::vector< webrtc::VideoStream > GetSimulcastConfig (size_t max_streams, int width, int height, int max_bitrate_bps, int max_qp, int max_framerate, bool is_screencast=false)
 
bool UseSimulcastScreenshare ()
 
bool ValidateRtpExtensions (const std::vector< webrtc::RtpExtension > &extensions)
 
std::vector< webrtc::RtpExtension > FilterRtpExtensions (const std::vector< webrtc::RtpExtension > &extensions, bool(*supported)(const std::string &), bool filter_redundant_extensions)
 
webrtc::Call::Config::BitrateConfig GetBitrateConfigForCodec (const Codec &codec)
 
bool BadTransportDescription (const std::string &desc, std::string *err_desc)
 
bool IceCredentialsChanged (const std::string &old_ufrag, const std::string &old_pwd, const std::string &new_ufrag, const std::string &new_pwd)
 
bool VerifyCandidate (const Candidate &candidate, std::string *error)
 
bool VerifyCandidates (const Candidates &candidates, std::string *error)
 
const char * ProtoToString (ProtocolType proto)
 
bool StringToProto (const char *value, ProtocolType *proto)
 
const ContentInfo * FindContentInfoByName (const ContentInfos &contents, const std::string &name)
 
const ContentInfo * FindContentInfoByType (const ContentInfos &contents, const std::string &type)
 
int GetStunSuccessResponseType (int request_type)
 
int GetStunErrorResponseType (int request_type)
 
bool IsStunRequestType (int msg_type)
 
bool IsStunIndicationType (int msg_type)
 
bool IsStunSuccessResponseType (int msg_type)
 
bool IsStunErrorResponseType (int msg_type)
 
bool ComputeStunCredentialHash (const std::string &username, const std::string &realm, const std::string &password, std::string *hash)
 
bool StringToConnectionRole (const std::string &role_str, ConnectionRole *role)
 
bool ConnectionRoleToString (const ConnectionRole &role, std::string *role_str)
 
std::string MediaContentDirectionToString (MediaContentDirection direction)
 
RtpTransceiverDirection NegotiateRtpTransceiverDirection (RtpTransceiverDirection offer, RtpTransceiverDirection wants)
 
bool IsMediaContent (const ContentInfo *content)
 
bool IsAudioContent (const ContentInfo *content)
 
bool IsVideoContent (const ContentInfo *content)
 
bool IsDataContent (const ContentInfo *content)
 
const ContentInfo * GetFirstMediaContent (const ContentInfos &contents, MediaType media_type)
 
const ContentInfo * GetFirstAudioContent (const ContentInfos &contents)
 
const ContentInfo * GetFirstVideoContent (const ContentInfos &contents)
 
const ContentInfo * GetFirstDataContent (const ContentInfos &contents)
 
const ContentInfo * GetFirstAudioContent (const SessionDescription *sdesc)
 
const ContentInfo * GetFirstVideoContent (const SessionDescription *sdesc)
 
const ContentInfo * GetFirstDataContent (const SessionDescription *sdesc)
 
const AudioContentDescription * GetFirstAudioContentDescription (const SessionDescription *sdesc)
 
const VideoContentDescription * GetFirstVideoContentDescription (const SessionDescription *sdesc)
 
const DataContentDescription * GetFirstDataContentDescription (const SessionDescription *sdesc)
 
ContentInfo * GetFirstMediaContent (ContentInfos &contents, MediaType media_type)
 
ContentInfo * GetFirstAudioContent (ContentInfos &contents)
 
ContentInfo * GetFirstVideoContent (ContentInfos &contents)
 
ContentInfo * GetFirstDataContent (ContentInfos &contents)
 
ContentInfo * GetFirstAudioContent (SessionDescription *sdesc)
 
ContentInfo * GetFirstVideoContent (SessionDescription *sdesc)
 
ContentInfo * GetFirstDataContent (SessionDescription *sdesc)
 
AudioContentDescription * GetFirstAudioContentDescription (SessionDescription *sdesc)
 
VideoContentDescription * GetFirstVideoContentDescription (SessionDescription *sdesc)
 
DataContentDescription * GetFirstDataContentDescription (SessionDescription *sdesc)
 
void GetSupportedAudioCryptoSuites (const rtc::CryptoOptions &crypto_options, std::vector< int > *crypto_suites)
 
void GetSupportedVideoCryptoSuites (const rtc::CryptoOptions &crypto_options, std::vector< int > *crypto_suites)
 
void GetSupportedDataCryptoSuites (const rtc::CryptoOptions &crypto_options, std::vector< int > *crypto_suites)
 
void GetDefaultSrtpCryptoSuites (const rtc::CryptoOptions &crypto_options, std::vector< int > *crypto_suites)
 
void GetSupportedAudioCryptoSuiteNames (const rtc::CryptoOptions &crypto_options, std::vector< std::string > *crypto_suite_names)
 
void GetSupportedVideoCryptoSuiteNames (const rtc::CryptoOptions &crypto_options, std::vector< std::string > *crypto_suite_names)
 
void GetSupportedDataCryptoSuiteNames (const rtc::CryptoOptions &crypto_options, std::vector< std::string > *crypto_suite_names)
 
void GetDefaultSrtpCryptoSuiteNames (const rtc::CryptoOptions &crypto_options, std::vector< std::string > *crypto_suite_names)
 
void ShutdownSrtp ()
 
const DataCodec * FindUnknownCodec (const std::vector< DataCodec > &codecs)
 
const DataCodec * FindKnownCodec (const std::vector< DataCodec > &codecs)
 
bool GetUint8 (const void *data, size_t offset, int *value)
 
bool GetUint16 (const void *data, size_t offset, int *value)
 
bool GetUint32 (const void *data, size_t offset, uint32_t *value)
 
bool SetUint8 (void *data, size_t offset, uint8_t value)
 
bool SetUint16 (void *data, size_t offset, uint16_t value)
 
bool SetUint32 (void *data, size_t offset, uint32_t value)
 
bool GetRtpFlags (const void *data, size_t len, int *value)
 
 TEST (RtpUtilsTest, GetRtp)
 
 TEST (RtpUtilsTest, SetRtpHeader)
 
 TEST (RtpUtilsTest, GetRtpHeaderLen)
 
 TEST (RtpUtilsTest, GetRtcp)
 
 TEST (RtpUtilsTest, InvalidRtpHeader)
 
 TEST (RtpUtilsTest, Valid2ByteExtnHdrRtpMessage)
 
 TEST (RtpUtilsTest, ValidRtpPacketWithAbsSendTimeExtension)
 
 TEST (RtpUtilsTest, UpdateAbsSendTimeExtensionIn2ByteHeaderExtn)
 
 TEST (RtpUtilsTest, UpdateAbsSendTimeExtensionInTurnSendIndication)
 
 TEST (RtpUtilsTest, ApplyPacketOptionsWithDefaultValues)
 
 TEST (RtpUtilsTest, ApplyPacketOptionsWithAuthParams)
 
 TEST (RtpUtilsTest, UpdateAbsSendTimeExtensionInRtpPacket)
 
 TEST (RtpUtilsTest, ApplyPacketOptionsWithAuthParamsAndAbsSendTime)
 
bool GetStream (const StreamParamsVec &streams, const StreamSelector &selector, StreamParams *stream_out)
 
 TEST (TurnUtilsTest, InvalidTurnSendIndicationMessages)
 
 TEST (TurnUtilsTest, ValidTurnSendIndicationMessage)
 
 TEST (TurnUtilsTest, ValidTurnChannelMessages)
 
 TEST (TurnUtilsTest, ChannelMessageZeroLength)
 
 TEST_F (VideoAdapterTest, AdaptNothing)
 
 TEST_F (VideoAdapterTest, AdaptZeroInterval)
 
 TEST_F (VideoAdapterTest, AdaptFramerateToHalf)
 
 TEST_F (VideoAdapterTest, AdaptFramerateToTwoThirds)
 
 TEST_F (VideoAdapterTest, AdaptFramerateHighLimit)
 
 TEST_F (VideoAdapterTest, AdaptFramerateTimestampOffset)
 
 TEST_F (VideoAdapterTest, AdaptFramerateTimestampJitter)
 
 TEST_F (VideoAdapterTest, AdaptFramerateOntheFly)
 
 TEST_F (VideoAdapterTest, AdaptFrameResolutionHighLimit)
 
 TEST_F (VideoAdapterTest, AdaptFrameResolutionIdentical)
 
 TEST_F (VideoAdapterTest, AdaptFrameResolutionQuarter)
 
 TEST_F (VideoAdapterTest, AdaptFrameResolutionDrop)
 
 TEST_F (VideoAdapterTest, AdaptResolution)
 
 TEST_F (VideoAdapterTest, AdaptResolutionOnTheFly)
 
 TEST_F (VideoAdapterTest, DropAllFrames)
 
 TEST_F (VideoAdapterTest, TestOnOutputFormatRequest)
 
 TEST_F (VideoAdapterTest, TestViewRequestPlusCameraSwitch)
 
 TEST_F (VideoAdapterTest, TestVGAWidth)
 
 TEST_F (VideoAdapterTest, TestOnResolutionRequestInSmallSteps)
 
 TEST_F (VideoAdapterTest, TestOnResolutionRequestMaxZero)
 
 TEST_F (VideoAdapterTest, TestOnResolutionRequestInLargeSteps)
 
 TEST_F (VideoAdapterTest, TestOnOutputFormatRequestCapsMaxResolution)
 
 TEST_F (VideoAdapterTest, TestOnResolutionRequestReset)
 
 TEST_F (VideoAdapterTest, TestCroppingWithResolutionRequest)
 
 TEST_F (VideoAdapterTest, TestCroppingOddResolution)
 
 TEST_F (VideoAdapterTest, TestAdaptToVerySmallResolution)
 
 TEST_F (VideoAdapterTest, AdaptFrameResolutionDropWithResolutionRequest)
 
 TEST_F (VideoAdapterTest, TestAdaptToMax)
 
 TEST (VideoCommonTest, TestCanonicalFourCC)
 
 TEST (VideoCommonTest, TestVideoFormatFps)
 
 TEST (VideoCommonTest, TestVideoFormatIsSize0x0)
 
 TEST (VideoCommonTest, TestVideoFormatToString)
 
 TEST (VideoCommonTest, TestVideoFormatCompare)
 
 TEST (NullWebRtcVideoEngineTest, CheckInterface)
 
 TEST_F (PayloadTypeMapperTest, StaticPayloadTypes)
 
 TEST_F (PayloadTypeMapperTest, WebRTCPayloadTypes)
 
 TEST_F (PayloadTypeMapperTest, ValidDynamicPayloadTypes)
 
 TEST_F (PayloadTypeMapperTest, ToAudioCodec)
 
void MaybeExchangeWidthHeight (int *width, int *height)
 
int FindSimulcastFormatIndex (int width, int height)
 
int FindSimulcastFormatIndex (int width, int height, size_t max_layers)
 
int NormalizeSimulcastSize (int size, size_t simulcast_layers)
 
size_t FindSimulcastMaxLayers (int width, int height)
 
int FindSimulcastMaxBitrateBps (int width, int height)
 
int FindSimulcastTargetBitrateBps (int width, int height)
 
int FindSimulcastMinBitrateBps (int width, int height)
 
bool SlotSimulcastMaxResolution (size_t max_layers, int *width, int *height)
 
 TEST_F (ScreenshareLayerConfigTest, UsesDefaultBitrateConfigForDefaultGroup)
 
 TEST_F (ScreenshareLayerConfigTest, UsesDefaultConfigForInvalidBitrates)
 
 TEST_F (ScreenshareLayerConfigTest, ParsesValidBitrateConfig)
 
 TEST (WebRtcMediaEngineTest, ValidateRtpExtensions_EmptyList)
 
 TEST (WebRtcMediaEngineTest, ValidateRtpExtensions_AllGood)
 
 TEST (WebRtcMediaEngineTest, ValidateRtpExtensions_OutOfRangeId_Low)
 
 TEST (WebRtcMediaEngineTest, ValidateRtpExtensions_OutOfRangeId_High)
 
 TEST (WebRtcMediaEngineTest, ValidateRtpExtensions_OverlappingIds_StartOfSet)
 
 TEST (WebRtcMediaEngineTest, ValidateRtpExtensions_OverlappingIds_EndOfSet)
 
 TEST (WebRtcMediaEngineTest, FilterRtpExtensions_EmptyList)
 
 TEST (WebRtcMediaEngineTest, FilterRtpExtensions_IncludeOnlySupported)
 
 TEST (WebRtcMediaEngineTest, FilterRtpExtensions_SortedByName_1)
 
 TEST (WebRtcMediaEngineTest, FilterRtpExtensions_SortedByName_2)
 
 TEST (WebRtcMediaEngineTest, FilterRtpExtensions_DontRemoveRedundant)
 
 TEST (WebRtcMediaEngineTest, FilterRtpExtensions_RemoveRedundant)
 
 TEST (WebRtcMediaEngineTest, FilterRtpExtensions_RemoveRedundantBwe_1)
 
 TEST (WebRtcMediaEngineTest, FilterRtpExtensions_RemoveRedundantBwe_2)
 
 TEST (WebRtcMediaEngineTest, FilterRtpExtensions_RemoveRedundantBwe_3)
 
 TEST (WebRtcMediaEngineFactoryTest, CreateOldApi)
 
 TEST (WebRtcMediaEngineFactoryTest, CreateWithBuiltinDecoders)
 
 TEST_F (WebRtcVideoEngine2Test, AnnouncesVp9AccordingToBuildFlags)
 
 TEST_F (WebRtcVideoEngine2Test, DefaultRtxCodecHasAssociatedPayloadTypeSet)
 
 TEST_F (WebRtcVideoEngine2Test, SupportsTimestampOffsetHeaderExtension)
 
 TEST_F (WebRtcVideoEngine2Test, SupportsAbsoluteSenderTimeHeaderExtension)
 
 TEST_F (WebRtcVideoEngine2Test, SupportsTransportSequenceNumberHeaderExtension)
 
 TEST_F (WebRtcVideoEngine2Test, SupportsVideoRotationHeaderExtension)
 
 TEST_F (WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer)
 
 TEST_F (WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeAddSendStream)
 
 TEST_F (WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer)
 
 TEST_F (WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs)
 
 TEST_F (WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash)
 
 TEST_F (WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported)
 
 TEST_F (WebRtcVideoEngine2Test, RtxCodecAddedForExternalCodec)
 
 TEST_F (WebRtcVideoEngine2Test, EnablesFullEncoderTimeForExternalEncoders)
 
 TEST_F (WebRtcVideoEngine2Test, DisablesFullEncoderTimeForNonExternalEncoders)
 
 TEST_F (WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory)
 
 TEST_F (WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp)
 
 TEST_F (WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories)
 
 TEST_F (WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8)
 
 TEST_F (WebRtcVideoEngine2Test, DontUseExternalEncoderFactoryForUnsupportedCodecs)
 
 TEST_F (WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory)
 
 TEST_F (WebRtcVideoEngine2Test, DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory)
 
 TEST_F (WebRtcVideoEngine2Test, SimulcastDisabledForH264)
 
 TEST_F (WebRtcVideoEngine2Test, Flexfec03SupportedAsInternalCodecBehindFieldTrial)
 
 TEST_F (WebRtcVideoEngine2Test, ReportSupportedExternalCodecs)
 
 TEST_F (WebRtcVideoEngine2Test, ReportSupportedExternalCodecsWithAddedCodec)
 
 TEST_F (WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported)
 
 TEST_F (WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported)
 
 TEST_F (WebRtcVideoEngine2Test, StreamParamsIdPassedToDecoderFactory)
 
 TEST_F (WebRtcVideoEngine2Test, DISABLED_RecreatesEncoderOnContentTypeChange)
 
 WEBRTC_BASE_TEST (SetSend)
 
 WEBRTC_BASE_TEST (SetSendWithoutCodecs)
 
 WEBRTC_BASE_TEST (SetSendSetsTransportBufferSizes)
 
 WEBRTC_BASE_TEST (GetStats)
 
 WEBRTC_BASE_TEST (GetStatsMultipleRecvStreams)
 
 WEBRTC_BASE_TEST (GetStatsMultipleSendStreams)
 
 WEBRTC_BASE_TEST (SetSendBandwidth)
 
 WEBRTC_BASE_TEST (SetSendSsrc)
 
 WEBRTC_BASE_TEST (SetSendSsrcAfterSetCodecs)
 
 WEBRTC_BASE_TEST (SetSink)
 
 WEBRTC_BASE_TEST (AddRemoveSendStreams)
 
 WEBRTC_BASE_TEST (SimulateConference)
 
 WEBRTC_DISABLED_BASE_TEST (AddRemoveCapturer)
 
 WEBRTC_BASE_TEST (RemoveCapturerWithoutAdd)
 
 WEBRTC_BASE_TEST (AddRemoveCapturerMultipleSources)
 
 WEBRTC_BASE_TEST (RejectEmptyStreamParams)
 
 WEBRTC_BASE_TEST (MultipleSendStreams)
 
 TEST_F (WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga)
 
 TEST_F (WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga)
 
 TEST_F (WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga)
 
 TEST_F (WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive)
 
 TEST_F (WebRtcVideoChannel2Test, SetsSyncGroupFromSyncLabel)
 
 TEST_F (WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx)
 
 TEST_F (WebRtcVideoChannel2Test, RecvStreamWithRtx)
 
 TEST_F (WebRtcVideoChannel2Test, RecvStreamNoRtx)
 
 TEST_F (WebRtcVideoChannel2Test, NoHeaderExtesionsByDefault)
 
 TEST_F (WebRtcVideoChannel2Test, SendRtpTimestampOffsetHeaderExtensions)
 
 TEST_F (WebRtcVideoChannel2Test, RecvRtpTimestampOffsetHeaderExtensions)
 
 TEST_F (WebRtcVideoChannel2Test, SendAbsoluteSendTimeHeaderExtensions)
 
 TEST_F (WebRtcVideoChannel2Test, RecvAbsoluteSendTimeHeaderExtensions)
 
 TEST_F (WebRtcVideoChannel2Test, FiltersExtensionsPicksTransportSeqNum)
 
 TEST_F (WebRtcVideoChannel2Test, FiltersExtensionsPicksAbsSendTime)
 
 TEST_F (WebRtcVideoChannel2Test, SendTransportSequenceNumberHeaderExtensions)
 
 TEST_F (WebRtcVideoChannel2Test, RecvTransportSequenceNumberHeaderExtensions)
 
 TEST_F (WebRtcVideoChannel2Test, SendVideoRotationHeaderExtensions)
 
 TEST_F (WebRtcVideoChannel2Test, RecvVideoRotationHeaderExtensions)
 
 TEST_F (WebRtcVideoChannel2Test, IdenticalSendExtensionsDoesntRecreateStream)
 
 TEST_F (WebRtcVideoChannel2Test, IdenticalRecvExtensionsDoesntRecreateStream)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsExcludeUnsupportedExtensions)
 
 TEST_F (WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsExcludeUnsupportedExtensions)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsIncorrectIds)
 
 TEST_F (WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsIncorrectIds)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsDuplicateIds)
 
 TEST_F (WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsDuplicateIds)
 
 TEST_F (WebRtcVideoChannel2Test, AddRecvStreamOnlyUsesOneReceiveStream)
 
 TEST_F (WebRtcVideoChannel2Test, RtcpIsCompoundByDefault)
 
 TEST_F (WebRtcVideoChannel2Test, RembIsEnabledByDefault)
 
 TEST_F (WebRtcVideoChannel2Test, TransportCcIsEnabledByDefault)
 
 TEST_F (WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled)
 
 TEST_F (WebRtcVideoChannel2Test, TransportCcCanBeEnabledAndDisabled)
 
 TEST_F (WebRtcVideoChannel2Test, NackIsEnabledByDefault)
 
 TEST_F (WebRtcVideoChannel2Test, NackCanBeEnabledAndDisabled)
 
 TEST_F (WebRtcVideoChannel2Test, ReconfiguresEncodersWhenNotSending)
 
 TEST_F (WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast)
 
 TEST_F (WebRtcVideoChannel2Test, ConferenceModeScreencastConfiguresTemporalLayer)
 
 TEST_F (WebRtcVideoChannel2Test, SuspendBelowMinBitrateDisabledByDefault)
 
 TEST_F (WebRtcVideoChannel2Test, SetMediaConfigSuspendBelowMinBitrate)
 
 TEST_F (WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault)
 
 TEST_F (WebRtcVideoChannel2Test, VerifyVp8SpecificSettings)
 
 TEST_F (WebRtcVideoChannel2Test, SetIdenticalOptionsDoesntReconfigureEncoder)
 
 TEST_F (Vp9SettingsTest, VerifyVp9SpecificSettings)
 
 TEST_F (Vp9SettingsTestWithNoFlag, VerifySettings)
 
 TEST_F (Vp9SettingsTestWithInvalidFlag, VerifySettings)
 
 TEST_F (Vp9SettingsTestWith2SL3TLFlag, VerifySettings)
 
 TEST_F (WebRtcVideoChannel2Test, AdaptsOnOveruse)
 
 TEST_F (WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenDisabled)
 
 TEST_F (WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenScreensharing)
 
 TEST_F (WebRtcVideoChannel2Test, AdaptsOnOveruseAndChangeResolution)
 
 TEST_F (WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare)
 
 TEST_F (WebRtcVideoChannel2Test, EstimatesNtpStartTimeCorrectly)
 
 TEST_F (WebRtcVideoChannel2Test, SetDefaultSendCodecs)
 
 TEST_F (WebRtcVideoChannel2Test, FlexfecCodecWithoutSsrcNotExposedByDefault)
 
 TEST_F (WebRtcVideoChannel2Test, FlexfecCodecWithSsrcNotExposedByDefault)
 
 TEST_F (WebRtcVideoChannel2FlexfecTest, DefaultFlexfecCodecHasTransportCcAndRembFeedbackParam)
 
 TEST_F (WebRtcVideoChannel2FlexfecTest, SetDefaultSendCodecsWithoutSsrc)
 
 TEST_F (WebRtcVideoChannel2FlexfecTest, SetDefaultSendCodecsWithSsrc)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsWithoutFec)
 
 TEST_F (WebRtcVideoChannel2FlexfecTest, SetSendCodecsWithoutFec)
 
 TEST_F (WebRtcVideoChannel2FlexfecTest, SetRecvCodecsWithFec)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecRejectsRtxWithoutAssociatedPayloadType)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecRejectsRtxWithoutMatchingVideoCodec)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsWithChangedRtxPayloadType)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec)
 
 TEST_F (WebRtcVideoChannel2FlexfecTest, SetSendCodecsWithoutFecDisablesFec)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsChangesExistingStreams)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsWithBitrates)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsWithHighMaxBitrate)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsWithoutBitratesUsesCorrectDefaults)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsCapsMinAndStartBitrate)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsRejectsMaxLessThanMinBitrate)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsWithBitratesAndMaxSendBandwidth)
 
 TEST_F (WebRtcVideoChannel2Test, SetMaxSendBandwidthShouldPreserveOtherBitrates)
 
 TEST_F (WebRtcVideoChannel2Test, SetMaxSendBandwidthShouldBeRemovable)
 
 TEST_F (WebRtcVideoChannel2Test, SetMaxSendBandwidthAndAddSendStream)
 
 TEST_F (WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate)
 
 TEST_F (WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsIdenticalFirstCodecDoesntRecreateStream)
 
 TEST_F (WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8)
 
 TEST_F (WebRtcVideoChannel2Test, SetRecvCodecsWithRtx)
 
 TEST_F (WebRtcVideoChannel2Test, SetRecvCodecsWithChangedRtxPayloadType)
 
 TEST_F (WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType)
 
 TEST_F (WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs)
 
 TEST_F (WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec)
 
 TEST_F (WebRtcVideoChannel2Test, DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs)
 
 TEST_F (WebRtcVideoChannel2Test, DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs)
 
 TEST_F (WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec)
 
 TEST_F (WebRtcVideoChannel2FlexfecTest, SetRecvParamsWithoutFecDisablesFec)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendParamsWithFecEnablesFec)
 
 TEST_F (WebRtcVideoChannel2FlexfecTest, SetSendParamsWithFecEnablesFec)
 
 TEST_F (WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads)
 
 TEST_F (WebRtcVideoChannel2FlexfecTest, SetSendCodecsRejectDuplicateFecPayloads)
 
 TEST_F (WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads)
 
 TEST_F (WebRtcVideoChannel2Test, SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes)
 
 TEST_F (WebRtcVideoChannel2Test, SetRecvCodecsDifferentOrderDoesntRecreateStream)
 
 TEST_F (WebRtcVideoChannel2Test, SendStreamNotSendingByDefault)
 
 TEST_F (WebRtcVideoChannel2Test, ReceiveStreamReceivingByDefault)
 
 TEST_F (WebRtcVideoChannel2Test, SetSend)
 
 TEST_F (WebRtcVideoChannel2Test, TestSetDscpOptions)
 
 TEST_F (WebRtcVideoChannel2Test, TestSetSendRtcpReducedSize)
 
 TEST_F (WebRtcVideoChannel2Test, TestSetRecvRtcpReducedSize)
 
 TEST_F (WebRtcVideoChannel2Test, OnReadyToSendSignalsNetworkState)
 
 TEST_F (WebRtcVideoChannel2Test, GetStatsReportsSentCodecName)
 
 TEST_F (WebRtcVideoChannel2Test, GetStatsReportsEncoderImplementationName)
 
 TEST_F (WebRtcVideoChannel2Test, GetStatsReportsCpuOveruseMetrics)
 
 TEST_F (WebRtcVideoChannel2Test, GetStatsReportsFramesEncoded)
 
 TEST_F (WebRtcVideoChannel2Test, GetStatsReportsQpSum)
 
 TEST_F (WebRtcVideoChannel2Test, GetStatsReportsUpperResolution)
 
 TEST_F (WebRtcVideoChannel2Test, GetStatsReportsPreferredBitrate)
 
 TEST_F (WebRtcVideoChannel2Test, GetStatsReportsCpuAdaptationStats)
 
 TEST_F (WebRtcVideoChannel2Test, GetStatsReportsAdaptationAndBandwidthStats)
 
 TEST_F (WebRtcVideoChannel2Test, GetStatsTranslatesBandwidthLimitedResolutionCorrectly)
 
 TEST_F (WebRtcVideoChannel2Test, GetStatsTranslatesSendRtcpPacketTypesCorrectly)
 
 TEST_F (WebRtcVideoChannel2Test, GetStatsTranslatesReceiveRtcpPacketTypesCorrectly)
 
 TEST_F (WebRtcVideoChannel2Test, GetStatsTranslatesDecodeStatsCorrectly)
 
 TEST_F (WebRtcVideoChannel2Test, GetStatsTranslatesReceivePacketStatsCorrectly)
 
 TEST_F (WebRtcVideoChannel2Test, TranslatesCallStatsCorrectly)
 
 TEST_F (WebRtcVideoChannel2Test, TranslatesSenderBitrateStatsCorrectly)
 
 TEST_F (WebRtcVideoChannel2Test, DefaultReceiveStreamReconfiguresToUseRtx)
 
 TEST_F (WebRtcVideoChannel2Test, RejectsAddingStreamsWithMissingSsrcsForRtx)
 
 TEST_F (WebRtcVideoChannel2Test, RejectsAddingStreamsWithOverlappingRtxSsrcs)
 
 TEST_F (WebRtcVideoChannel2Test, RejectsAddingStreamsWithOverlappingSimulcastSsrcs)
 
 TEST_F (WebRtcVideoChannel2Test, ReportsSsrcGroupsInStats)
 
 TEST_F (WebRtcVideoChannel2Test, MapsReceivedPayloadTypeToCodecName)
 
 TEST_F (WebRtcVideoChannel2Test, Vp8PacketCreatesUnsignalledStream)
 
 TEST_F (WebRtcVideoChannel2Test, Vp9PacketCreatesUnsignalledStream)
 
 TEST_F (WebRtcVideoChannel2Test, RtxPacketDoesntCreateUnsignalledStream)
 
 TEST_F (WebRtcVideoChannel2Test, UlpfecPacketDoesntCreateUnsignalledStream)
 
 TEST_F (WebRtcVideoChannel2FlexfecTest, FlexfecPacketDoesntCreateUnsignalledStream)
 
 TEST_F (WebRtcVideoChannel2Test, RedRtxPacketDoesntCreateUnsignalledStream)
 
 TEST_F (WebRtcVideoChannel2Test, ReceiveDifferentUnsignaledSsrc)
 
 TEST_F (WebRtcVideoChannel2Test, CanSentMaxBitrateForExistingStream)
 
 TEST_F (WebRtcVideoChannel2Test, CannotSetMaxBitrateForNonexistentStream)
 
 TEST_F (WebRtcVideoChannel2Test, CannotSetRtpSendParametersWithIncorrectNumberOfEncodings)
 
 TEST_F (WebRtcVideoChannel2Test, CannotSetSsrcInRtpSendParameters)
 
 TEST_F (WebRtcVideoChannel2Test, SetRtpSendParametersEncodingsActive)
 
 TEST_F (WebRtcVideoChannel2Test, InactiveStreamDoesntStartSendingWhenReconfigured)
 
 TEST_F (WebRtcVideoChannel2Test, GetRtpSendParametersCodecs)
 
 TEST_F (WebRtcVideoChannel2Test, GetRtpSendParametersSsrc)
 
 TEST_F (WebRtcVideoChannel2Test, SetAndGetRtpSendParameters)
 
 TEST_F (WebRtcVideoChannel2Test, GetRtpReceiveParametersCodecs)
 
 TEST_F (WebRtcVideoChannel2Test, DISABLED_GetRtpReceiveFmtpSprop)
 
 TEST_F (WebRtcVideoChannel2Test, GetRtpReceiveParametersSsrc)
 
 TEST_F (WebRtcVideoChannel2Test, SetAndGetRtpReceiveParameters)
 
 TEST_F (WebRtcVideoChannel2Test, ConfiguresLocalSsrc)
 
 TEST_F (WebRtcVideoChannel2Test, ConfiguresLocalSsrcOnExistingReceivers)
 
 TEST_F (WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams)
 
 TEST_F (WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams)
 
 TEST_F (WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast)
 
 TEST_F (WebRtcVideoChannel2SimulcastTest, SetSendCodecsForScreenshare)
 
 TEST_F (WebRtcVideoChannel2SimulcastTest, SetSendCodecsForConferenceModeScreenshare)
 
 TEST_F (WebRtcVideoChannel2SimulcastTest, SetSendCodecsForSimulcastScreenshare)
 
 TEST_F (SctpTransportTest, SwitchTransportChannel)
 
 TEST_F (SctpTransportTest, DuplicateStartCallsIgnored)
 
 TEST_F (SctpTransportTest, CallingStartWithDifferentPortFails)
 
 TEST_F (SctpTransportTest, NegativeOnePortTreatedAsDefault)
 
 TEST_F (SctpTransportTest, OpenStreamWithAlreadyOpenedStreamFails)
 
 TEST_F (SctpTransportTest, ResetStreamWithAlreadyResetStreamFails)
 
 TEST_F (SctpTransportTest, SignalReadyToSendDataAfterDtlsWritable)
 
 TEST_F (SctpTransportTest, SignalReadyToSendDataAfterBlocked)
 
 TEST_F (SctpTransportTest, SendData)
 
 TEST_F (SctpTransportTest, SendDataBlocked)
 
 TEST_F (SctpTransportTest, SendDataWithNonexistentStreamFails)
 
 TEST_F (SctpTransportTest, ClosesRemoteStream)
 
 TEST_F (SctpTransportTest, ClosesTwoRemoteStreams)
 
 TEST_F (SctpTransportTest, ClosesStreamsOnBothSides)
 
 TEST_F (SctpTransportTest, RefusesHighNumberedTransports)
 
 TEST_F (SctpTransportTest, DISABLED_ReusesAStream)
 
bool IsStunMessage (uint16_t msg_type)
 
 TEST_F (AsyncStunTCPSocketTest, TestSingleStunPacket)
 
 TEST_F (AsyncStunTCPSocketTest, TestMultipleStunPackets)
 
 TEST_F (AsyncStunTCPSocketTest, TestTurnChannelDataWithZeroLength)
 
 TEST_F (AsyncStunTCPSocketTest, TestTurnChannelData)
 
 TEST_F (AsyncStunTCPSocketTest, TestTurnChannelDataPadding)
 
 TEST_F (AsyncStunTCPSocketTest, TestStunInvalidLength)
 
 TEST_F (AsyncStunTCPSocketTest, TestTurnChannelDataWithInvalidLength)
 
 TEST_F (AsyncStunTCPSocketTest, TestTooSmallMessageBuffer)
 
 TEST_F (AsyncStunTCPSocketTest, TestMaximumSizeTurnPacket)
 
 TEST_F (AsyncStunTCPSocketTest, TestMaximumSizeStunPacket)
 
 TEST_F (AsyncStunTCPSocketTest, DISABLED_TestWithSmallSendBuffer)
 
 TEST_F (P2PTransportChannelTest, HandleUfragPwdChange)
 
 TEST_F (P2PTransportChannelTest, HandleUfragPwdChangeSymmetricNat)
 
 TEST_F (P2PTransportChannelTest, GetStats)
 
 TEST_F (P2PTransportChannelTest, TestUMAIceRestartWhileDisconnected)
 
 TEST_F (P2PTransportChannelTest, TestUMAIceRestartWhileConnected)
 
 TEST_F (P2PTransportChannelTest, TestUMAIceRestartWhileConnecting)
 
 TEST_F (P2PTransportChannelTest, TestIceRegatheringReasonContinualGatheringByNetworkChange)
 
 TEST_F (P2PTransportChannelTest, TestIceRegatheringReasonContinualGatheringByNetworkFailure)
 
 TEST_F (P2PTransportChannelTest, PeerReflexiveCandidateBeforeSignaling)
 
 TEST_F (P2PTransportChannelTest, PeerReflexiveCandidateBeforeSignalingWithNAT)
 
 TEST_F (P2PTransportChannelTest, PeerReflexiveCandidateBeforeSignalingWithIceRestart)
 
 TEST_F (P2PTransportChannelTest, RemoteCandidatesWithoutUfragPwd)
 
 TEST_F (P2PTransportChannelTest, IncomingOnlyBlocked)
 
 TEST_F (P2PTransportChannelTest, IncomingOnlyOpen)
 
 TEST_F (P2PTransportChannelTest, TestTcpConnectionsFromActiveToPassive)
 
 TEST_F (P2PTransportChannelTest, TestIceRoleConflict)
 
 TEST_F (P2PTransportChannelTest, TestIceConfigWillPassDownToPort)
 
 TEST_F (P2PTransportChannelTest, TestDefaultDscpValue)
 
 TEST_F (P2PTransportChannelTest, TestIPv6Connections)
 
 TEST_F (P2PTransportChannelTest, TestForceTurn)
 
 TEST_F (P2PTransportChannelTest, TestContinualGathering)
 
 TEST_F (P2PTransportChannelTest, TestUsingPooledSessionBeforeDoneGathering)
 
 TEST_F (P2PTransportChannelTest, TestUsingPooledSessionAfterDoneGathering)
 
 TEST_F (P2PTransportChannelTest, TurnToTurnPresumedWritable)
 
 TEST_F (P2PTransportChannelTest, TurnToPrflxPresumedWritable)
 
 TEST_F (P2PTransportChannelTest, PresumedWritablePreferredOverUnreliable)
 
 TEST_F (P2PTransportChannelTest, SignalReadyToSendWithPresumedWritable)
 
 TEST_F (P2PTransportChannelSameNatTest, TestConesBehindSameCone)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestBasic)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestFailoverControlledSide)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestFailoverControllingSide)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestFailoverWithManyConnections)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestIceRenomination)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestConnectionSwitchDampeningControlledSide)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestConnectionSwitchDampeningControllingSide)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestRemoteFailover)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestPreferWifiToWifiConnection)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestPreferWifiOverCellularNetwork)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestPingBackupConnectionRate)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestGetState)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestNetworkBecomesInactive)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestContinualGatheringOnNewInterface)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestSwitchLinksViaContinualGathering)
 
 TEST_F (P2PTransportChannelMultihomedTest, TestRestoreBackupConnection)
 
 TEST_F (P2PTransportChannelPingTest, TestTriggeredChecks)
 
 TEST_F (P2PTransportChannelPingTest, TestAllConnectionsPingedSufficiently)
 
 TEST_F (P2PTransportChannelPingTest, TestStunPingIntervals)
 
 TEST_F (P2PTransportChannelPingTest, PingingStartedAsSoonAsPossible)
 
 TEST_F (P2PTransportChannelPingTest, TestNoTriggeredChecksWhenWritable)
 
 TEST_F (P2PTransportChannelPingTest, TestFailedConnectionNotPingable)
 
 TEST_F (P2PTransportChannelPingTest, TestSignalStateChanged)
 
 TEST_F (P2PTransportChannelPingTest, TestAddRemoteCandidateWithVariousUfrags)
 
 TEST_F (P2PTransportChannelPingTest, ConnectionResurrection)
 
 TEST_F (P2PTransportChannelPingTest, TestReceivingStateChange)
 
 TEST_F (P2PTransportChannelPingTest, TestSelectConnectionBeforeNomination)
 
 TEST_F (P2PTransportChannelPingTest, TestSelectConnectionFromUnknownAddress)
 
 TEST_F (P2PTransportChannelPingTest, TestSelectConnectionBasedOnMediaReceived)
 
 TEST_F (P2PTransportChannelPingTest, TestControlledAgentDataReceivingTakesHigherPrecedenceThanPriority)
 
 TEST_F (P2PTransportChannelPingTest, TestControlledAgentNominationTakesHigherPrecedenceThanDataReceiving)
 
 TEST_F (P2PTransportChannelPingTest, TestControlledAgentSelectsConnectionWithHigherNomination)
 
 TEST_F (P2PTransportChannelPingTest, TestControlledAgentIgnoresSmallerNomination)
 
 TEST_F (P2PTransportChannelPingTest, TestControlledAgentWriteStateTakesHigherPrecedenceThanNomination)
 
 TEST_F (P2PTransportChannelPingTest, TestAddRemoteCandidateWithAddressReuse)
 
 TEST_F (P2PTransportChannelPingTest, TestDontPruneWhenWeak)
 
 TEST_F (P2PTransportChannelPingTest, TestDontPruneHighPriorityConnections)
 
 TEST_F (P2PTransportChannelPingTest, TestGetState)
 
 TEST_F (P2PTransportChannelPingTest, TestConnectionPrunedAgain)
 
 TEST_F (P2PTransportChannelPingTest, TestDeleteConnectionsIfAllWriteTimedout)
 
 TEST_F (P2PTransportChannelPingTest, TestStopPortAllocatorSessions)
 
 TEST_F (P2PTransportChannelPingTest, TestIceRoleUpdatedOnRemovedPort)
 
 TEST_F (P2PTransportChannelPingTest, TestIceRoleUpdatedOnPortAfterIceRestart)
 
 TEST_F (P2PTransportChannelPingTest, TestPortDestroyedAfterTimeoutAndPruned)
 
 TEST_F (P2PTransportChannelMostLikelyToWorkFirstTest, TestRelayRelayFirstWhenNothingPingedYet)
 
 TEST_F (P2PTransportChannelMostLikelyToWorkFirstTest, TestRelayRelayFirstWhenEverythingPinged)
 
 TEST_F (P2PTransportChannelMostLikelyToWorkFirstTest, TestNoStarvationOnNonRelayConnection)
 
 TEST_F (P2PTransportChannelMostLikelyToWorkFirstTest, TestTcpTurn)
 
void long_to_bytes (uint32_t val, void *buf)
 
void short_to_bytes (uint16_t val, void *buf)
 
uint32_t bytes_to_long (const void *buf)
 
uint16_t bytes_to_short (const void *buf)
 
uint32_t bound (uint32_t lower, uint32_t middle, uint32_t upper)
 
void Send (rtc::AsyncPacketSocket *socket, const char *bytes, size_t size, const rtc::SocketAddress &addr)
 
void SendStun (const StunMessage &msg, rtc::AsyncPacketSocket *socket, const rtc::SocketAddress &addr)
 
void SendStunError (const StunMessage &msg, rtc::AsyncPacketSocket *socket, const rtc::SocketAddress &remote_addr, int error_code, const char *error_desc, const std::string &magic_cookie)
 
ContentInfo * FindContentInfoByName (ContentInfos &contents, const std::string &name)
 
 TEST_F (StunTest, MessageTypes)
 
 TEST_F (StunTest, ReadMessageWithIPv4AddressAttribute)
 
 TEST_F (StunTest, ReadMessageWithIPv4XorAddressAttribute)
 
 TEST_F (StunTest, ReadMessageWithIPv6AddressAttribute)
 
 TEST_F (StunTest, ReadMessageWithInvalidAddressAttribute)
 
 TEST_F (StunTest, ReadMessageWithIPv6XorAddressAttribute)
 
 TEST_F (StunTest, ReadRfc5769RequestMessage)
 
 TEST_F (StunTest, ReadRfc5769ResponseMessage)
 
 TEST_F (StunTest, ReadRfc5769ResponseMessageIPv6)
 
 TEST_F (StunTest, ReadRfc5769RequestMessageLongTermAuth)
 
 TEST_F (StunTest, ReadLegacyMessage)
 
 TEST_F (StunTest, SetIPv6XorAddressAttributeOwner)
 
 TEST_F (StunTest, SetIPv4XorAddressAttributeOwner)
 
 TEST_F (StunTest, CreateIPv6AddressAttribute)
 
 TEST_F (StunTest, CreateIPv4AddressAttribute)
 
 TEST_F (StunTest, CreateAddressInArbitraryOrder)
 
 TEST_F (StunTest, WriteMessageWithIPv6AddressAttribute)
 
 TEST_F (StunTest, WriteMessageWithIPv4AddressAttribute)
 
 TEST_F (StunTest, WriteMessageWithIPv6XorAddressAttribute)
 
 TEST_F (StunTest, WriteMessageWithIPv4XoreAddressAttribute)
 
 TEST_F (StunTest, ReadByteStringAttribute)
 
 TEST_F (StunTest, ReadPaddedByteStringAttribute)
 
 TEST_F (StunTest, ReadErrorCodeAttribute)
 
 TEST_F (StunTest, ReadMessageWithAUInt16ListAttribute)
 
 TEST_F (StunTest, ReadMessageWithAnUnknownAttribute)
 
 TEST_F (StunTest, ReadMessageWithOriginAttribute)
 
 TEST_F (StunTest, WriteMessageWithAnErrorCodeAttribute)
 
 TEST_F (StunTest, WriteMessageWithAUInt16ListAttribute)
 
 TEST_F (StunTest, WriteMessageWithOriginAttribute)
 
void CheckFailureToRead (const unsigned char *testcase, size_t length)
 
 TEST_F (StunTest, FailToReadInvalidMessages)
 
 TEST_F (StunTest, FailToReadRtcpPacket)
 
 TEST_F (StunTest, ValidateMessageIntegrity)
 
 TEST_F (StunTest, AddMessageIntegrity)
 
 TEST_F (StunTest, ValidateFingerprint)
 
 TEST_F (StunTest, AddFingerprint)
 
 TEST_F (StunTest, ReadRelayMessage)
 
 TEST_F (TransportControllerTest, TestSetIceConfig)
 
 TEST_F (TransportControllerTest, TestSetSslMaxProtocolVersion)
 
 TEST_F (TransportControllerTest, TestSetIceRole)
 
 TEST_F (TransportControllerTest, TestIceRoleConflict)
 
 TEST_F (TransportControllerTest, TestGetSslRole)
 
 TEST_F (TransportControllerTest, TestSetAndGetLocalCertificate)
 
 TEST_F (TransportControllerTest, TestGetRemoteSSLCertificate)
 
 TEST_F (TransportControllerTest, TestSetLocalTransportDescription)
 
 TEST_F (TransportControllerTest, TestSetRemoteTransportDescription)
 
 TEST_F (TransportControllerTest, TestAddRemoteCandidates)
 
 TEST_F (TransportControllerTest, TestReadyForRemoteCandidates)
 
 TEST_F (TransportControllerTest, TestGetStats)
 
 TEST_F (TransportControllerTest, TestCreateAndDestroyFakeDtlsTransport)
 
 TEST_F (TransportControllerTest, TestSignalConnectionStateFailed)
 
 TEST_F (TransportControllerTest, TestSignalConnectionStateConnected)
 
 TEST_F (TransportControllerTest, TestSignalConnectionStateComplete)
 
 TEST_F (TransportControllerTest, TestDestroyTransportAndStayConnected)
 
 TEST_F (TransportControllerTest, TestDestroyLastTransportWhileConnected)
 
 TEST_F (TransportControllerTest, TestSignalReceiving)
 
 TEST_F (TransportControllerTest, TestSignalGatheringStateGathering)
 
 TEST_F (TransportControllerTest, TestSignalGatheringStateComplete)
 
 TEST_F (TransportControllerTest, TestSignalingWhenLastIncompleteTransportDestroyed)
 
 TEST_F (TransportControllerTest, TestSignalCandidatesGathered)
 
 TEST_F (TransportControllerTest, TestSignalingOccursOnSignalingThread)
 
 TEST_F (TransportControllerTest, IceRoleRedeterminedOnIceRestartByDefault)
 
 TEST_F (TransportControllerTest, IceRoleNotRedetermined)
 
 TEST_F (TransportControllerTest, TestSetRemoteIceLiteInOffer)
 
 TEST_F (TransportControllerTest, TestSetRemoteIceLiteInAnswer)
 
 TEST_F (TransportControllerTest, NeedsIceRestart)
 
bool IsTurnChannelData (uint16_t msg_type)
 
 TEST_F (TurnPortTest, TestTurnPortType)
 
 TEST_F (TurnPortTest, TestReconstructedServerUrl)
 
 TEST_F (TurnPortTest, TestTurnAllocate)
 
 TEST_F (TurnPortTest, TestTurnTcpAllocate)
 
 TEST_F (TurnPortTest, TestTurnTcpAllocationWhenProxyChangesAddressToLocalHost)
 
 TEST_F (TurnPortTest, TestTurnTcpOnAddressResolveFailure)
 
 TEST_F (TurnPortTest, TestTurnUdpOnAddressResolveFailure)
 
 TEST_F (TurnPortTest, TestTurnAllocateBadPassword)
 
 TEST_F (TurnPortTest, TestTurnAllocateNonceResetAfterAllocateMismatch)
 
 TEST_F (TurnPortTest, TestTurnAllocateMismatch)
 
 TEST_F (TurnPortTest, TestSharedSocketAllocateMismatch)
 
 TEST_F (TurnPortTest, TestTurnTcpAllocateMismatch)
 
 TEST_F (TurnPortTest, TestRefreshRequestGetsErrorResponse)
 
 TEST_F (TurnPortTest, TestStopProcessingPacketsAfterClosed)
 
 TEST_F (TurnPortTest, TestCreateConnectionWhenSocketClosed)
 
 TEST_F (TurnPortTest, TestSocketCloseWillDestroyConnection)
 
 TEST_F (TurnPortTest, TestTurnAlternateServerUDP)
 
 TEST_F (TurnPortTest, TestTurnAlternateServerTCP)
 
 TEST_F (TurnPortTest, TestTurnAlternateServerV4toV6UDP)
 
 TEST_F (TurnPortTest, TestTurnAlternateServerV4toV6TCP)
 
 TEST_F (TurnPortTest, TestTurnAlternateServerPingPongUDP)
 
 TEST_F (TurnPortTest, TestTurnAlternateServerPingPongTCP)
 
 TEST_F (TurnPortTest, TestTurnAlternateServerDetectRepetitionUDP)
 
 TEST_F (TurnPortTest, TestTurnAlternateServerDetectRepetitionTCP)
 
 TEST_F (TurnPortTest, TestTurnAlternateServerLoopbackUdpIpv4)
 
 TEST_F (TurnPortTest, TestTurnAlternateServerLoopbackUdpIpv6)
 
 TEST_F (TurnPortTest, TestTurnAlternateServerLoopbackTcpIpv4)
 
 TEST_F (TurnPortTest, TestTurnAlternateServerLoopbackTcpIpv6)
 
 TEST_F (TurnPortTest, TestTurnConnection)
 
 TEST_F (TurnPortTest, TestTurnConnectionUsingSharedSocket)
 
 TEST_F (TurnPortTest, TestTurnTcpConnection)
 
 TEST_F (TurnPortTest, TestDestroyTurnConnection)
 
 TEST_F (TurnPortTest, TestDestroyTurnConnectionUsingSharedSocket)
 
 TEST_F (TurnPortTest, TestTurnTlsTcpConnectionFails)
 
 TEST_F (TurnPortTest, TestTurnConnectionUsingOTUNonce)
 
 TEST_F (TurnPortTest, TestRefreshCreatePermissionRequest)
 
 TEST_F (TurnPortTest, TestChannelBindGetErrorResponse)
 
 TEST_F (TurnPortTest, TestTurnSendDataTurnUdpToUdp)
 
 TEST_F (TurnPortTest, TestTurnSendDataTurnTcpToUdp)
 
 TEST_F (TurnPortTest, TestTurnLocalIPv6AddressServerIPv4)
 
 TEST_F (TurnPortTest, TestTurnLocalIPv6AddressServerIPv6ExtenalIPv4)
 
 TEST_F (TurnPortTest, TestCandidateAddressFamilyMatch)
 
 TEST_F (TurnPortTest, TestOriginHeader)
 
 TEST_F (TurnPortTest, TestConnectionFailedAndPrunedOnCreatePermissionFailure)
 
 TEST_F (TurnPortTest, TestTurnReleaseAllocation)
 
 TEST_F (TurnPortTest, TestTurnTCPReleaseAllocation)
 
 TEST_F (TurnServerConnectionTest, ComparisonOperators)
 
 TEST_F (UdpTransportTest, AddressGetters)
 
 TEST_F (UdpTransportTest, SettingIncompleteRemoteAddressFails)
 
 TEST_F (UdpTransportTest, SendRecvBasic)
 
 TEST_F (UdpTransportTest, StatusAndSignals)
 
std::ostream & operator<< (std::ostream &os, const std::vector< Candidate > &candidates)
 
 TEST_F (BasicPortAllocatorTest, TestBasic)
 
 TEST_F (BasicPortAllocatorTest, TestIgnoreOnlyLoopbackNetworkByDefault)
 
 TEST_F (BasicPortAllocatorTest, TestIgnoreNetworksAccordingToIgnoreMask)
 
 TEST_F (BasicPortAllocatorTest, TestGatherLowCostNetworkOnly)
 
 TEST_F (BasicPortAllocatorTest, TestLoopbackNetworkInterface)
 
 TEST_F (BasicPortAllocatorTest, TestGetAllPortsWithMinimumStepDelay)
 
 TEST_F (BasicPortAllocatorTest, TestSameNetworkDownAndUpWhenSessionNotStopped)
 
 TEST_F (BasicPortAllocatorTest, TestSameNetworkDownAndUpWhenSessionStopped)
 
 TEST_F (BasicPortAllocatorTest, TestGetAllPortsWithOneSecondStepDelay)
 
 TEST_F (BasicPortAllocatorTest, TestSetupVideoRtpPortsWithNormalSendBuffers)
 
 TEST_F (BasicPortAllocatorTest, TestStopGetAllPorts)
 
 TEST_F (BasicPortAllocatorTest, TestGetAllPortsPortRange)
 
 TEST_F (BasicPortAllocatorTest, TestGetAllPortsNoAdapters)
 
 TEST_F (BasicPortAllocatorTest, TestDisableAdapterEnumerationWithoutNatRelayTransportOnly)
 
 TEST_F (BasicPortAllocatorTest, TestDisableAdapterEnumerationBehindNatMultipleInterfaces)
 
 TEST_F (BasicPortAllocatorTest, TestDisableAdapterEnumerationBehindNatWithTcp)
 
 TEST_F (BasicPortAllocatorTest, TestDisableAdapterEnumerationWithoutNatOrServers)
 
 TEST_F (BasicPortAllocatorTest, TestDisableAdapterEnumerationWithoutNatLocalhostCandidateDisabled)
 
 TEST_F (BasicPortAllocatorTest, TestDisableAdapterEnumerationWithoutNatLocalhostCandidateDisabledWithDifferentDefaultRoute)
 
 TEST_F (BasicPortAllocatorTest, TestDisableAdapterEnumerationWithNatLocalhostCandidateDisabled)
 
 TEST_F (BasicPortAllocatorTest, TestDisableUdpTurn)
 
 TEST_F (BasicPortAllocatorTest, TestDisableAllPorts)
 
 TEST_F (BasicPortAllocatorTest, TestGetAllPortsNoUdpSockets)
 
 TEST_F (BasicPortAllocatorTest, TestGetAllPortsNoUdpSocketsNoTcpListen)
 
 TEST_F (BasicPortAllocatorTest, TestGetAllPortsNoSockets)
 
 TEST_F (BasicPortAllocatorTest, TestGetAllPortsNoUdpAllowed)
 
 TEST_F (BasicPortAllocatorTest, TestCandidatePriorityOfMultipleInterfaces)
 
 TEST_F (BasicPortAllocatorTest, TestGetAllPortsRestarts)
 
 TEST_F (BasicPortAllocatorTest, TestSessionUsesOwnCandidateFilter)
 
 TEST_F (BasicPortAllocatorTest, TestCandidateFilterWithRelayOnly)
 
 TEST_F (BasicPortAllocatorTest, TestCandidateFilterWithHostOnly)
 
 TEST_F (BasicPortAllocatorTest, TestCandidateFilterWithReflexiveOnly)
 
 TEST_F (BasicPortAllocatorTest, TestCandidateFilterWithReflexiveOnlyAndNoNAT)
 
 TEST_F (BasicPortAllocatorTest, TestEnableSharedUfrag)
 
 TEST_F (BasicPortAllocatorTest, TestSharedSocketWithoutNat)
 
 TEST_F (BasicPortAllocatorTest, TestSharedSocketWithNat)
 
 TEST_F (BasicPortAllocatorTest, TestSharedSocketWithoutNatUsingTurn)
 
 TEST_F (BasicPortAllocatorTest, TestUdpTurnPortPrunesTcpTurnPortWithTcpPortReadyFirst)
 
 TEST_F (BasicPortAllocatorTest, TestUdpTurnPortPrunesTcpTurnPortsWithUdpPortReadyFirst)
 
 TEST_F (BasicPortAllocatorTest, TestIPv6TurnPortPrunesIPv4TurnPortWithIPv4PortReadyFirst)
 
 TEST_F (BasicPortAllocatorTest, TestIPv6TurnPortPrunesIPv4TurnPortWithIPv6PortReadyFirst)
 
 TEST_F (BasicPortAllocatorTest, TestEachInterfaceHasItsOwnTurnPortsNoDelay)
 
 TEST_F (BasicPortAllocatorTest, TestEachInterfaceHasItsOwnTurnPortsWithTcpIPv4ReadyFirst)
 
 TEST_F (BasicPortAllocatorTestWithRealClock, TestSharedSocketWithServerAddressResolve)
 
 TEST_F (BasicPortAllocatorTest, TestSharedSocketWithNatUsingTurn)
 
 TEST_F (BasicPortAllocatorTest, TestSharedSocketWithNatUsingTurnAsStun)
 
 TEST_F (BasicPortAllocatorTest, TestSharedSocketWithNatUsingTurnTcpOnly)
 
 TEST_F (BasicPortAllocatorTest, TestNonSharedSocketWithNatUsingTurnAsStun)
 
 TEST_F (BasicPortAllocatorTest, TestSharedSocketWithNatUsingTurnAndStun)
 
 TEST_F (BasicPortAllocatorTest, TestSharedSocketNoUdpAllowed)
 
 TEST_F (BasicPortAllocatorTest, TestNetworkPermissionBlocked)
 
 TEST_F (BasicPortAllocatorTest, TestEnableIPv6Addresses)
 
 TEST_F (BasicPortAllocatorTest, TestStopGettingPorts)
 
 TEST_F (BasicPortAllocatorTest, TestClearGettingPorts)
 
 TEST_F (BasicPortAllocatorTest, TestTransportInformationUpdated)
 
 TEST_F (BasicPortAllocatorTest, TestSetCandidateFilterAfterCandidatesGathered)
 
template<class Codec >
void RtpParametersFromMediaDescription (const MediaContentDescriptionImpl< Codec > *desc, RtpParameters< Codec > *params)
 
template<class Codec >
void RtpSendParametersFromMediaDescription (const MediaContentDescriptionImpl< Codec > *desc, RtpSendParameters< Codec > *send_params)
 
 TEST_F (ChannelManagerTest, StartupShutdown)
 
 TEST_F (ChannelManagerTest, StartupShutdownOnThread)
 
 TEST_F (ChannelManagerTest, CreateDestroyChannels)
 
 TEST_F (ChannelManagerTest, CreateDestroyChannelsOnThread)
 
 TEST_F (ChannelManagerTest, SetVideoRtxEnabled)
 
 TEST_F (CurrentSpeakerMonitorTest, NoActiveStreams)
 
 TEST_F (CurrentSpeakerMonitorTest, MultipleActiveStreams)
 
 TEST_F (CurrentSpeakerMonitorTest, DISABLED_RapidSpeakerChange)
 
 TEST_F (CurrentSpeakerMonitorTest, MAYBE_SpeakerChange)
 
 TEST_F (CurrentSpeakerMonitorTest, InterwordSilence)
 
const CryptoParamsVec * GetCryptos (const MediaContentDescription *media)
 
bool FindMatchingCrypto (const CryptoParamsVec &cryptos, const CryptoParams &crypto, CryptoParams *out)
 
void FilterDataCodecs (std::vector< DataCodec > *codecs, bool sctp)
 
const MediaContentDescription * GetFirstMediaContentDescription (const SessionDescription *sdesc, MediaType media_type)
 
MediaContentDescription * GetFirstMediaContentDescription (SessionDescription *sdesc, MediaType media_type)
 
bool IsRtcp (const char *data, int len)
 

Variables

const int kScreencastDefaultFps = 5
 
const int kVideoCodecClockrate = 90000
 
const int kDataCodecClockrate = 90000
 
const int kDataMaxBandwidth = 30720
 
const float kHighSystemCpuThreshold = 0.85f
 
const float kLowSystemCpuThreshold = 0.65f
 
const float kProcessCpuThreshold = 0.10f
 
const char kRtxCodecName [] = "rtx"
 
const char kRedCodecName [] = "red"
 
const char kUlpfecCodecName [] = "ulpfec"
 
const char kFlexfecCodecName [] = "flexfec-03"
 
const char kFlexfecFmtpRepairWindow [] = "repair-window"
 
const char kCodecParamAssociatedPayloadType [] = "apt"
 
const char kOpusCodecName [] = "opus"
 
const char kIsacCodecName [] = "isac"
 
const char kL16CodecName [] = "l16"
 
const char kG722CodecName [] = "g722"
 
const char kIlbcCodecName [] = "ilbc"
 
const char kPcmuCodecName [] = "pcmu"
 
const char kPcmaCodecName [] = "pcma"
 
const char kCnCodecName [] = "cn"
 
const char kDtmfCodecName [] = "telephone-event"
 
const char kCodecParamPTime [] = "ptime"
 
const char kCodecParamMaxPTime [] = "maxptime"
 
const char kCodecParamMinPTime [] = "minptime"
 
const char kCodecParamSPropStereo [] = "sprop-stereo"
 
const char kCodecParamStereo [] = "stereo"
 
const char kCodecParamUseInbandFec [] = "useinbandfec"
 
const char kCodecParamUseDtx [] = "usedtx"
 
const char kCodecParamMaxAverageBitrate [] = "maxaveragebitrate"
 
const char kCodecParamMaxPlaybackRate [] = "maxplaybackrate"
 
const char kCodecParamSctpProtocol [] = "protocol"
 
const char kCodecParamSctpStreams [] = "streams"
 
const char kParamValueTrue [] = "1"
 
const char kParamValueEmpty [] = ""
 
const int kOpusDefaultMaxPTime = 120
 
const int kOpusDefaultPTime = 20
 
const int kOpusDefaultMinPTime = 3
 
const int kOpusDefaultSPropStereo = 0
 
const int kOpusDefaultStereo = 0
 
const int kOpusDefaultUseInbandFec = 0
 
const int kOpusDefaultUseDtx = 0
 
const int kOpusDefaultMaxPlaybackRate = 48000
 
const int kPreferredMaxPTime = 120
 
const int kPreferredMinPTime = 10
 
const int kPreferredSPropStereo = 0
 
const int kPreferredStereo = 0
 
const int kPreferredUseInbandFec = 0
 
const char kRtcpFbParamNack [] = "nack"
 
const char kRtcpFbNackParamPli [] = "pli"
 
const char kRtcpFbParamRemb [] = "goog-remb"
 
const char kRtcpFbParamTransportCc [] = "transport-cc"
 
const char kRtcpFbParamCcm [] = "ccm"
 
const char kRtcpFbCcmParamFir [] = "fir"
 
const char kCodecParamMaxBitrate [] = "x-google-max-bitrate"
 
const char kCodecParamMinBitrate [] = "x-google-min-bitrate"
 
const char kCodecParamStartBitrate [] = "x-google-start-bitrate"
 
const char kCodecParamMaxQuantization [] = "x-google-max-quantization"
 
const char kCodecParamPort [] = "x-google-port"
 
const int kGoogleRtpDataCodecPlType = 109
 
const char kGoogleRtpDataCodecName [] = "google-data"
 
const int kGoogleSctpDataCodecPlType = 108
 
const char kGoogleSctpDataCodecName [] = "google-sctp-data"
 
const char kComfortNoiseCodecName [] = "CN"
 
const char kVp8CodecName [] = "VP8"
 
const char kVp9CodecName [] = "VP9"
 
const char kH264CodecName [] = "H264"
 
const char kH264FmtpProfileLevelId [] = "profile-level-id"
 
const char kH264FmtpLevelAsymmetryAllowed [] = "level-asymmetry-allowed"
 
const char kH264FmtpPacketizationMode [] = "packetization-mode"
 
const char kH264FmtpSpropParameterSets [] = "sprop-parameter-sets"
 
const char kH264ProfileLevelConstrainedBaseline [] = "42e01f"
 
const int kDefaultVideoMaxFramerate = 60
 
const size_t kMinRtpPacketLen = 12
 
const size_t kMaxRtpPacketLen = 2048
 
const size_t kMinRtcpPacketLen = 4
 
const char kFecSsrcGroupSemantics [] = "FEC"
 
const char kFecFrSsrcGroupSemantics [] = "FEC-FR"
 
const char kFidSsrcGroupSemantics [] = "FID"
 
const char kSimSsrcGroupSemantics [] = "SIM"
 
const uint32_t kDummyVideoSsrc = 0xFFFFFFFF
 
const int kVideoMtu = 1200
 
const int kVideoRtpBufferSize = 65536
 
const int kMinVideoBitrateKbps = 30
 
constexpr uint16_t kMaxSctpStreams = 1024
 
constexpr uint16_t kMaxSctpSid = kMaxSctpStreams - 1
 
constexpr uint16_t kMinSctpSid = 0
 
const int kSctpDefaultPort = 5000
 
const char CN_AUDIO [] = "audio"
 
const char CN_VIDEO [] = "video"
 
const char CN_DATA [] = "data"
 
const char CN_OTHER [] = "main"
 
const char GROUP_TYPE_BUNDLE [] = "BUNDLE"
 
const int ICE_UFRAG_LENGTH = 4
 
const int ICE_PWD_LENGTH = 24
 
const size_t ICE_UFRAG_MIN_LENGTH = 4
 
const size_t ICE_PWD_MIN_LENGTH = 22
 
const size_t ICE_UFRAG_MAX_LENGTH = 255
 
const size_t ICE_PWD_MAX_LENGTH = 256
 
const int ICE_CANDIDATE_COMPONENT_RTP = 1
 
const int ICE_CANDIDATE_COMPONENT_RTCP = 2
 
const int ICE_CANDIDATE_COMPONENT_DEFAULT = 1
 
const char NS_JINGLE_RTP [] = "urn:xmpp:jingle:apps:rtp:1"
 
const char NS_JINGLE_DRAFT_SCTP [] = "google:jingle:sctp"
 
const char CONNECTIONROLE_ACTIVE_STR [] = "active"
 
const char CONNECTIONROLE_PASSIVE_STR [] = "passive"
 
const char CONNECTIONROLE_ACTPASS_STR [] = "actpass"
 
const char CONNECTIONROLE_HOLDCONN_STR [] = "holdconn"
 
const int WEAK_PING_INTERVAL = 1000 * PING_PACKET_SIZE / 10000
 
const int STRONG_PING_INTERVAL = 1000 * PING_PACKET_SIZE / 1000
 
const int WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL = 900
 
const int STRONG_AND_STABLE_WRITABLE_CONNECTION_PING_INTERVAL = 2500
 
const char LOCAL_PORT_TYPE [] = "local"
 
const char STUN_PORT_TYPE [] = "stun"
 
const char PRFLX_PORT_TYPE [] = "prflx"
 
const char RELAY_PORT_TYPE [] = "relay"
 
const char UDP_PROTOCOL_NAME [] = "udp"
 
const char TCP_PROTOCOL_NAME [] = "tcp"
 
const char SSLTCP_PROTOCOL_NAME [] = "ssltcp"
 
const char TLS_PROTOCOL_NAME [] = "tls"
 
const int DISCARD_PORT = 9
 
const char TCPTYPE_ACTIVE_STR [] = "active"
 
const char TCPTYPE_PASSIVE_STR [] = "passive"
 
const char TCPTYPE_SIMOPEN_STR [] = "so"
 
const uint32_t kDefaultPortAllocatorFlags = 0
 
const uint32_t kDefaultStepDelay = 1000
 
const uint32_t kMinimumStepDelay = 50
 
const char STUN_ERROR_REASON_TRY_ALTERNATE_SERVER [] = "Try Alternate Server"
 
const char STUN_ERROR_REASON_BAD_REQUEST [] = "Bad Request"
 
const char STUN_ERROR_REASON_UNAUTHORIZED [] = "Unauthorized"
 
const char STUN_ERROR_REASON_UNKNOWN_ATTRIBUTE []
 
const char STUN_ERROR_REASON_STALE_CREDENTIALS [] = "Stale Credentials"
 
const char STUN_ERROR_REASON_STALE_NONCE [] = "Stale Nonce"
 
const char STUN_ERROR_REASON_SERVER_ERROR [] = "Server Error"
 
const uint32_t kStunTypeMask = 0x0110
 
const size_t kStunAttributeHeaderSize = 4
 
const size_t kStunHeaderSize = 20
 
const size_t kStunTransactionIdOffset = 8
 
const size_t kStunTransactionIdLength = 12
 
const uint32_t kStunMagicCookie = 0x2112A442
 
const size_t kStunMagicCookieLength = sizeof(kStunMagicCookie)
 
const size_t kStunLegacyTransactionIdLength = 16
 
const size_t kStunMessageIntegritySize = 20
 
const char TURN_MAGIC_COOKIE_VALUE [4] = { '\x72', '\xC6', '\x4B', '\xC6' }
 
const char STUN_ERROR_REASON_FORBIDDEN [] = "Forbidden"
 
const char STUN_ERROR_REASON_ALLOCATION_MISMATCH [] = "Allocation Mismatch"
 
const char STUN_ERROR_REASON_WRONG_CREDENTIALS [] = "Wrong Credentials"
 
const char STUN_ERROR_REASON_UNSUPPORTED_PROTOCOL [] = "Unsupported Protocol"
 
const char STUN_ERROR_REASON_ROLE_CONFLICT [] = "Role Conflict"
 
const int kAllRequests = 0
 
const int STUN_TOTAL_TIMEOUT = 39750
 
const int STUN_SERVER_PORT = 3478
 
constexpr auto ICE_RENOMINATION_STR = "renomination"
 
const char TURN_PORT_TYPE []
 
const int TURN_SERVER_PORT = 3478
 
const char kMediaProtocolAvpf [] = "RTP/AVPF"
 
const char kMediaProtocolSavpf [] = "RTP/SAVPF"
 
const char kMediaProtocolDtlsSavpf [] = "UDP/TLS/RTP/SAVPF"
 
const char kMediaProtocolRtpPrefix [] = "RTP/"
 
const char kMediaProtocolSctp [] = "SCTP"
 
const char kMediaProtocolDtlsSctp [] = "DTLS/SCTP"
 
const char kMediaProtocolUdpDtlsSctp [] = "UDP/DTLS/SCTP"
 
const char kMediaProtocolTcpDtlsSctp [] = "TCP/DTLS/SCTP"
 
const int kAutoBandwidth = -1
 
const int kBufferedModeDisabled = 0
 
const char kDefaultRtcpCname [] = "DefaultRtcpCname"
 
const SimulcastFormat kSimulcastFormats []
 
const int kDefaultScreenshareSimulcastStreams = 2
 
const uint16_t PACKET_MAXIMUMS []
 
const uint32_t MAX_PACKET = 65535
 
const uint32_t MIN_PACKET = 296
 
const uint32_t IP_HEADER_SIZE = 20
 
const uint32_t UDP_HEADER_SIZE = 8
 
const uint32_t JINGLE_HEADER_SIZE = 64
 
const uint32_t DEFAULT_RCV_BUF_SIZE = 60 * 1024
 
const uint32_t DEFAULT_SND_BUF_SIZE = 90 * 1024
 
const uint32_t HEADER_SIZE = 24
 
const uint32_t PACKET_OVERHEAD
 
const uint32_t MIN_RTO
 
const uint32_t DEF_RTO = 3000
 
const uint32_t MAX_RTO = 60000
 
const uint32_t DEF_ACK_DELAY = 100
 
const uint8_t FLAG_CTL = 0x02
 
const uint8_t FLAG_RST = 0x04
 
const uint8_t CTL_CONNECT = 0
 
const uint8_t TCP_OPT_EOL = 0
 
const uint8_t TCP_OPT_NOOP = 1
 
const uint8_t TCP_OPT_MSS = 2
 
const uint8_t TCP_OPT_WND_SCALE = 3
 
const long DEFAULT_TIMEOUT = 4000
 
const long CLOSED_TIMEOUT = 60 * 1000
 
const int MAX_LIFETIME = 15 * 60 * 1000
 
const uint32_t USERNAME_LENGTH = 16
 
const uint32_t MSG_LIFETIME_TIMER = 1
 
const char EMPTY_TRANSACTION_ID [] = "0000000000000000"
 
const uint32_t STUN_FINGERPRINT_XOR_VALUE = 0x5354554E
 
const unsigned char kTestTransactionId1 []
 
const unsigned char kTestTransactionId2 []
 
const in6_addr kIPv6TestAddress1
 
const in6_addr kIPv6TestAddress2
 
const char kTestUserName1 [] = "abcdefgh"
 
const char kTestUserName2 [] = "abc"
 
const char kTestErrorReason [] = "Unauthorized"
 
const char kTestOrigin [] = "http://example.com"
 
const int kTestErrorClass = 4
 
const int kTestErrorNumber = 1
 
const int kTestErrorCode = 401
 
const int kTestMessagePort1 = 59977
 
const int kTestMessagePort2 = 47233
 
const int kTestMessagePort3 = 56743
 
const int kTestMessagePort4 = 40444
 
const int KEEPALIVE_DELAY = 10 * 1000
 
const int RETRY_TIMEOUT = 50 * 1000
 
const uint32_t MSG_STUN_SEND = 1
 
const int STUN_INITIAL_RTO = 250
 
const int STUN_MAX_RETRANSMISSIONS = 8
 
const int STUN_MAX_RTO = 8000
 
constexpr int kTimeoutMs = 10000
 
const uint32_t DISABLE_ALL_PHASES
 

Typedef Documentation

◆ AudioCodecs

typedef std::vector< AudioCodec > cricket::AudioCodecs

◆ Candidates

typedef std::vector< Candidate > cricket::Candidates

◆ CodecParameterMap

typedef std::map< std::string, std::string > cricket::CodecParameterMap

◆ ConnectionInfos

typedef std::vector< ConnectionInfo > cricket::ConnectionInfos

◆ ContentGroups

typedef std::vector< ContentGroup > cricket::ContentGroups

◆ ContentInfos

typedef std::vector< ContentInfo > cricket::ContentInfos

◆ ContentNames

typedef std::vector< std::string > cricket::ContentNames

◆ CryptoParamsVec

typedef std::vector< CryptoParams > cricket::CryptoParamsVec

◆ DataCodecs

typedef std::vector< DataCodec > cricket::DataCodecs

◆ DataMediaMonitor

typedef MediaMonitorT< DataMediaChannel, DataMediaInfo > cricket::DataMediaMonitor

◆ PacketLength

typedef uint16_t cricket::PacketLength

◆ PortList

typedef std::vector< ProtocolAddress > cricket::PortList

◆ RtpCodecParametersMap

typedef std::map< int, webrtc::RtpCodecParameters > cricket::RtpCodecParametersMap

◆ RtpHeaderExtensions

typedef std::vector< webrtc::RtpExtension > cricket::RtpHeaderExtensions

◆ ServerAddresses

typedef std::set< rtc::SocketAddress > cricket::ServerAddresses

◆ StreamParamsVec

typedef std::vector< StreamParams > cricket::StreamParamsVec

◆ TransportChannelStatsList

typedef std::vector< TransportChannelStats > cricket::TransportChannelStatsList

◆ TransportControllerForTest

typedef FakeTransportController cricket::TransportControllerForTest

◆ TransportInfos

typedef std::vector< TransportInfo > cricket::TransportInfos

◆ VideoCodecs

typedef std::vector< VideoCodec > cricket::VideoCodecs

◆ VideoFrame

typedef webrtc::VideoFrame cricket::VideoFrame

◆ VideoMediaMonitor

typedef MediaMonitorT< VideoMediaChannel, VideoMediaInfo > cricket::VideoMediaMonitor

◆ VoiceMediaMonitor

typedef MediaMonitorT< VoiceMediaChannel, VoiceMediaInfo > cricket::VoiceMediaMonitor

◆ WebRtcVideoFrame

typedef webrtc::VideoFrame cricket::WebRtcVideoFrame

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
MSG_ALLOCATION_TIMEOUT 

◆ anonymous enum

anonymous enum
Enumerator
MSG_MONITOR_POLL 
MSG_MONITOR_START 
MSG_MONITOR_STOP 
MSG_MONITOR_SIGNAL 

◆ anonymous enum

anonymous enum
Enumerator
MSG_EARLYMEDIATIMEOUT 
MSG_SEND_RTP_PACKET 
MSG_SEND_RTCP_PACKET 
MSG_CHANNEL_ERROR 
MSG_READYTOSENDDATA 
MSG_DATARECEIVED 
MSG_FIRSTPACKETRECEIVED 

◆ anonymous enum

anonymous enum
Enumerator
MSG_MONITOR_POLL 
MSG_MONITOR_START 
MSG_MONITOR_STOP 
MSG_MONITOR_SIGNAL 

◆ anonymous enum

anonymous enum
Enumerator
PORTALLOCATOR_DISABLE_UDP 
PORTALLOCATOR_DISABLE_STUN 
PORTALLOCATOR_DISABLE_RELAY 
PORTALLOCATOR_DISABLE_TCP 
PORTALLOCATOR_ENABLE_IPV6 
PORTALLOCATOR_ENABLE_SHARED_UFRAG 
PORTALLOCATOR_ENABLE_SHARED_SOCKET 
PORTALLOCATOR_ENABLE_STUN_RETRANSMIT_ATTRIBUTE 
PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION 
PORTALLOCATOR_DISABLE_DEFAULT_LOCAL_CANDIDATE 
PORTALLOCATOR_DISABLE_UDP_RELAY 
PORTALLOCATOR_DISABLE_COSTLY_NETWORKS 

◆ anonymous enum

anonymous enum
Enumerator
CF_NONE 
CF_HOST 
CF_REFLEXIVE 
CF_RELAY 
CF_ALL 

◆ anonymous enum

anonymous enum
Enumerator
PORTALLOCATOR_DISABLE_UDP 
PORTALLOCATOR_DISABLE_STUN 
PORTALLOCATOR_DISABLE_RELAY 
PORTALLOCATOR_DISABLE_TCP 
PORTALLOCATOR_ENABLE_IPV6 
PORTALLOCATOR_ENABLE_SHARED_UFRAG 
PORTALLOCATOR_ENABLE_SHARED_SOCKET 
PORTALLOCATOR_ENABLE_STUN_RETRANSMIT_ATTRIBUTE 
PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION 
PORTALLOCATOR_DISABLE_DEFAULT_LOCAL_CANDIDATE 
PORTALLOCATOR_DISABLE_UDP_RELAY 
PORTALLOCATOR_DISABLE_COSTLY_NETWORKS 

◆ anonymous enum

anonymous enum
Enumerator
CF_NONE 
CF_HOST 
CF_REFLEXIVE 
CF_RELAY 
CF_ALL 

◆ CaptureState [1/2]

enum cricket::CaptureState
Enumerator
CS_STOPPED 
CS_STARTING 
CS_RUNNING 
CS_FAILED 
CS_STOPPED 
CS_STARTING 
CS_RUNNING 
CS_FAILED 

◆ CaptureState [2/2]

enum cricket::CaptureState
Enumerator
CS_STOPPED 
CS_STARTING 
CS_RUNNING 
CS_FAILED 
CS_STOPPED 
CS_STARTING 
CS_RUNNING 
CS_FAILED 

◆ ConnectionRole [1/2]

enum cricket::ConnectionRole
Enumerator
CONNECTIONROLE_NONE 
CONNECTIONROLE_ACTIVE 
CONNECTIONROLE_PASSIVE 
CONNECTIONROLE_ACTPASS 
CONNECTIONROLE_HOLDCONN 
CONNECTIONROLE_NONE 
CONNECTIONROLE_ACTIVE 
CONNECTIONROLE_PASSIVE 
CONNECTIONROLE_ACTPASS 
CONNECTIONROLE_HOLDCONN 

◆ ConnectionRole [2/2]

enum cricket::ConnectionRole
Enumerator
CONNECTIONROLE_NONE 
CONNECTIONROLE_ACTIVE 
CONNECTIONROLE_PASSIVE 
CONNECTIONROLE_ACTPASS 
CONNECTIONROLE_HOLDCONN 
CONNECTIONROLE_NONE 
CONNECTIONROLE_ACTIVE 
CONNECTIONROLE_PASSIVE 
CONNECTIONROLE_ACTPASS 
CONNECTIONROLE_HOLDCONN 

◆ ContentAction [1/2]

enum cricket::ContentAction
Enumerator
CA_OFFER 
CA_PRANSWER 
CA_ANSWER 
CA_UPDATE 
CA_OFFER 
CA_PRANSWER 
CA_ANSWER 
CA_UPDATE 

◆ ContentAction [2/2]

enum cricket::ContentAction
Enumerator
CA_OFFER 
CA_PRANSWER 
CA_ANSWER 
CA_UPDATE 
CA_OFFER 
CA_PRANSWER 
CA_ANSWER 
CA_UPDATE 

◆ ContentSource [1/2]

enum cricket::ContentSource
Enumerator
CS_LOCAL 
CS_REMOTE 
CS_LOCAL 
CS_REMOTE 

◆ ContentSource [2/2]

enum cricket::ContentSource
Enumerator
CS_LOCAL 
CS_REMOTE 
CS_LOCAL 
CS_REMOTE 

◆ ContinualGatheringPolicy [1/2]

enum cricket::ContinualGatheringPolicy
Enumerator
GATHER_ONCE 
GATHER_CONTINUALLY 
GATHER_CONTINUALLY_AND_RECOVER 
GATHER_ONCE 
GATHER_CONTINUALLY 
GATHER_CONTINUALLY_AND_RECOVER 

◆ ContinualGatheringPolicy [2/2]

enum cricket::ContinualGatheringPolicy
Enumerator
GATHER_ONCE 
GATHER_CONTINUALLY 
GATHER_CONTINUALLY_AND_RECOVER 
GATHER_ONCE 
GATHER_CONTINUALLY 
GATHER_CONTINUALLY_AND_RECOVER 

◆ CryptoType [1/2]

enum cricket::CryptoType
Enumerator
CT_NONE 
CT_SDES 
CT_DTLS 
CT_NONE 
CT_SDES 
CT_DTLS 

◆ CryptoType [2/2]

enum cricket::CryptoType
Enumerator
CT_NONE 
CT_SDES 
CT_DTLS 
CT_NONE 
CT_SDES 
CT_DTLS 

◆ DataChannelType [1/2]

enum cricket::DataChannelType
Enumerator
DCT_NONE 
DCT_RTP 
DCT_SCTP 
DCT_QUIC 
DCT_NONE 
DCT_RTP 
DCT_SCTP 
DCT_QUIC 

◆ DataChannelType [2/2]

enum cricket::DataChannelType
Enumerator
DCT_NONE 
DCT_RTP 
DCT_SCTP 
DCT_QUIC 
DCT_NONE 
DCT_RTP 
DCT_SCTP 
DCT_QUIC 

◆ DataMessageType [1/2]

enum cricket::DataMessageType
Enumerator
DMT_NONE 
DMT_CONTROL 
DMT_BINARY 
DMT_TEXT 
DMT_NONE 
DMT_CONTROL 
DMT_BINARY 
DMT_TEXT 

◆ DataMessageType [2/2]

enum cricket::DataMessageType
Enumerator
DMT_NONE 
DMT_CONTROL 
DMT_BINARY 
DMT_TEXT 
DMT_NONE 
DMT_CONTROL 
DMT_BINARY 
DMT_TEXT 

◆ DtlsTransportState [1/2]

enum cricket::DtlsTransportState
Enumerator
DTLS_TRANSPORT_NEW 
DTLS_TRANSPORT_CONNECTING 
DTLS_TRANSPORT_CONNECTED 
DTLS_TRANSPORT_CLOSED 
DTLS_TRANSPORT_FAILED 
DTLS_TRANSPORT_NEW 
DTLS_TRANSPORT_CONNECTING 
DTLS_TRANSPORT_CONNECTED 
DTLS_TRANSPORT_CLOSED 
DTLS_TRANSPORT_FAILED 

◆ DtlsTransportState [2/2]

enum cricket::DtlsTransportState
Enumerator
DTLS_TRANSPORT_NEW 
DTLS_TRANSPORT_CONNECTING 
DTLS_TRANSPORT_CONNECTED 
DTLS_TRANSPORT_CLOSED 
DTLS_TRANSPORT_FAILED 
DTLS_TRANSPORT_NEW 
DTLS_TRANSPORT_CONNECTING 
DTLS_TRANSPORT_CONNECTED 
DTLS_TRANSPORT_CLOSED 
DTLS_TRANSPORT_FAILED 

◆ FourCC [1/2]

enum cricket::FourCC
Enumerator
FOURCC_I420 
FOURCC_I422 
FOURCC_I444 
FOURCC_I411 
FOURCC_I400 
FOURCC_NV21 
FOURCC_NV12 
FOURCC_YUY2 
FOURCC_UYVY 
FOURCC_M420 
FOURCC_ARGB 
FOURCC_BGRA 
FOURCC_ABGR 
FOURCC_24BG 
FOURCC_RAW 
FOURCC_RGBA 
FOURCC_RGBP 
FOURCC_RGBO 
FOURCC_R444 
FOURCC_RGGB 
FOURCC_BGGR 
FOURCC_GRBG 
FOURCC_GBRG 
FOURCC_MJPG 
FOURCC_YV12 
FOURCC_YV16 
FOURCC_YV24 
FOURCC_YU12 
FOURCC_J420 
FOURCC_J400 
FOURCC_IYUV 
FOURCC_YU16 
FOURCC_YU24 
FOURCC_YUYV 
FOURCC_YUVS 
FOURCC_HDYC 
FOURCC_2VUY 
FOURCC_JPEG 
FOURCC_DMB1 
FOURCC_BA81 
FOURCC_RGB3 
FOURCC_BGR3 
FOURCC_CM32 
FOURCC_CM24 
FOURCC_H264 
FOURCC_I420 
FOURCC_I422 
FOURCC_I444 
FOURCC_I411 
FOURCC_I400 
FOURCC_NV21 
FOURCC_NV12 
FOURCC_YUY2 
FOURCC_UYVY 
FOURCC_M420 
FOURCC_ARGB 
FOURCC_BGRA 
FOURCC_ABGR 
FOURCC_24BG 
FOURCC_RAW 
FOURCC_RGBA 
FOURCC_RGBP 
FOURCC_RGBO 
FOURCC_R444 
FOURCC_RGGB 
FOURCC_BGGR 
FOURCC_GRBG 
FOURCC_GBRG 
FOURCC_MJPG 
FOURCC_YV12 
FOURCC_YV16 
FOURCC_YV24 
FOURCC_YU12 
FOURCC_J420 
FOURCC_J400 
FOURCC_IYUV 
FOURCC_YU16 
FOURCC_YU24 
FOURCC_YUYV 
FOURCC_YUVS 
FOURCC_HDYC 
FOURCC_2VUY 
FOURCC_JPEG 
FOURCC_DMB1 
FOURCC_BA81 
FOURCC_RGB3 
FOURCC_BGR3 
FOURCC_CM32 
FOURCC_CM24 
FOURCC_H264 

◆ FourCC [2/2]

enum cricket::FourCC
Enumerator
FOURCC_I420 
FOURCC_I422 
FOURCC_I444 
FOURCC_I411 
FOURCC_I400 
FOURCC_NV21 
FOURCC_NV12 
FOURCC_YUY2 
FOURCC_UYVY 
FOURCC_M420 
FOURCC_ARGB 
FOURCC_BGRA 
FOURCC_ABGR 
FOURCC_24BG 
FOURCC_RAW 
FOURCC_RGBA 
FOURCC_RGBP 
FOURCC_RGBO 
FOURCC_R444 
FOURCC_RGGB 
FOURCC_BGGR 
FOURCC_GRBG 
FOURCC_GBRG 
FOURCC_MJPG 
FOURCC_YV12 
FOURCC_YV16 
FOURCC_YV24 
FOURCC_YU12 
FOURCC_J420 
FOURCC_J400 
FOURCC_IYUV 
FOURCC_YU16 
FOURCC_YU24 
FOURCC_YUYV 
FOURCC_YUVS 
FOURCC_HDYC 
FOURCC_2VUY 
FOURCC_JPEG 
FOURCC_DMB1 
FOURCC_BA81 
FOURCC_RGB3 
FOURCC_BGR3 
FOURCC_CM32 
FOURCC_CM24 
FOURCC_H264 
FOURCC_I420 
FOURCC_I422 
FOURCC_I444 
FOURCC_I411 
FOURCC_I400 
FOURCC_NV21 
FOURCC_NV12 
FOURCC_YUY2 
FOURCC_UYVY 
FOURCC_M420 
FOURCC_ARGB 
FOURCC_BGRA 
FOURCC_ABGR 
FOURCC_24BG 
FOURCC_RAW 
FOURCC_RGBA 
FOURCC_RGBP 
FOURCC_RGBO 
FOURCC_R444 
FOURCC_RGGB 
FOURCC_BGGR 
FOURCC_GRBG 
FOURCC_GBRG 
FOURCC_MJPG 
FOURCC_YV12 
FOURCC_YV16 
FOURCC_YV24 
FOURCC_YU12 
FOURCC_J420 
FOURCC_J400 
FOURCC_IYUV 
FOURCC_YU16 
FOURCC_YU24 
FOURCC_YUYV 
FOURCC_YUVS 
FOURCC_HDYC 
FOURCC_2VUY 
FOURCC_JPEG 
FOURCC_DMB1 
FOURCC_BA81 
FOURCC_RGB3 
FOURCC_BGR3 
FOURCC_CM32 
FOURCC_CM24 
FOURCC_H264 

◆ IceAttributeType [1/2]

enum cricket::IceAttributeType
Enumerator
STUN_ATTR_PRIORITY 
STUN_ATTR_USE_CANDIDATE 
STUN_ATTR_ICE_CONTROLLED 
STUN_ATTR_ICE_CONTROLLING 
STUN_ATTR_NOMINATION 
STUN_ATTR_NETWORK_INFO 
STUN_ATTR_PRIORITY 
STUN_ATTR_USE_CANDIDATE 
STUN_ATTR_ICE_CONTROLLED 
STUN_ATTR_ICE_CONTROLLING 
STUN_ATTR_NOMINATION 
STUN_ATTR_NETWORK_INFO 

◆ IceAttributeType [2/2]

enum cricket::IceAttributeType
Enumerator
STUN_ATTR_PRIORITY 
STUN_ATTR_USE_CANDIDATE 
STUN_ATTR_ICE_CONTROLLED 
STUN_ATTR_ICE_CONTROLLING 
STUN_ATTR_NOMINATION 
STUN_ATTR_NETWORK_INFO 
STUN_ATTR_PRIORITY 
STUN_ATTR_USE_CANDIDATE 
STUN_ATTR_ICE_CONTROLLED 
STUN_ATTR_ICE_CONTROLLING 
STUN_ATTR_NOMINATION 
STUN_ATTR_NETWORK_INFO 

◆ IceCandidatePairState [1/2]

enum cricket::IceCandidatePairState
strong
Enumerator
WAITING 
IN_PROGRESS 
SUCCEEDED 
FAILED 
WAITING 
IN_PROGRESS 
SUCCEEDED 
FAILED 

◆ IceCandidatePairState [2/2]

enum cricket::IceCandidatePairState
strong
Enumerator
WAITING 
IN_PROGRESS 
SUCCEEDED 
FAILED 
WAITING 
IN_PROGRESS 
SUCCEEDED 
FAILED 

◆ IceConnectionState [1/2]

enum cricket::IceConnectionState
Enumerator
kIceConnectionConnecting 
kIceConnectionFailed 
kIceConnectionConnected 
kIceConnectionCompleted 
kIceConnectionConnecting 
kIceConnectionFailed 
kIceConnectionConnected 
kIceConnectionCompleted 

◆ IceConnectionState [2/2]

enum cricket::IceConnectionState
Enumerator
kIceConnectionConnecting 
kIceConnectionFailed 
kIceConnectionConnected 
kIceConnectionCompleted 
kIceConnectionConnecting 
kIceConnectionFailed 
kIceConnectionConnected 
kIceConnectionCompleted 

◆ IceErrorCode [1/2]

enum cricket::IceErrorCode
Enumerator
STUN_ERROR_ROLE_CONFLICT 
STUN_ERROR_ROLE_CONFLICT 

◆ IceErrorCode [2/2]

enum cricket::IceErrorCode
Enumerator
STUN_ERROR_ROLE_CONFLICT 
STUN_ERROR_ROLE_CONFLICT 

◆ IceGatheringState [1/2]

enum cricket::IceGatheringState
Enumerator
kIceGatheringNew 
kIceGatheringGathering 
kIceGatheringComplete 
kIceGatheringNew 
kIceGatheringGathering 
kIceGatheringComplete 

◆ IceGatheringState [2/2]

enum cricket::IceGatheringState
Enumerator
kIceGatheringNew 
kIceGatheringGathering 
kIceGatheringComplete 
kIceGatheringNew 
kIceGatheringGathering 
kIceGatheringComplete 

◆ IceMode [1/2]

enum cricket::IceMode
Enumerator
ICEMODE_FULL 
ICEMODE_LITE 
ICEMODE_FULL 
ICEMODE_LITE 

◆ IceMode [2/2]

enum cricket::IceMode
Enumerator
ICEMODE_FULL 
ICEMODE_LITE 
ICEMODE_FULL 
ICEMODE_LITE 

◆ IcePriorityValue [1/2]

enum cricket::IcePriorityValue
Enumerator
ICE_TYPE_PREFERENCE_RELAY_TLS 
ICE_TYPE_PREFERENCE_RELAY_TCP 
ICE_TYPE_PREFERENCE_RELAY_UDP 
ICE_TYPE_PREFERENCE_PRFLX_TCP 
ICE_TYPE_PREFERENCE_HOST_TCP 
ICE_TYPE_PREFERENCE_SRFLX 
ICE_TYPE_PREFERENCE_PRFLX 
ICE_TYPE_PREFERENCE_HOST 
ICE_TYPE_PREFERENCE_RELAY_TLS 
ICE_TYPE_PREFERENCE_RELAY_TCP 
ICE_TYPE_PREFERENCE_RELAY_UDP 
ICE_TYPE_PREFERENCE_PRFLX_TCP 
ICE_TYPE_PREFERENCE_HOST_TCP 
ICE_TYPE_PREFERENCE_SRFLX 
ICE_TYPE_PREFERENCE_PRFLX 
ICE_TYPE_PREFERENCE_HOST 

◆ IcePriorityValue [2/2]

enum cricket::IcePriorityValue
Enumerator
ICE_TYPE_PREFERENCE_RELAY_TLS 
ICE_TYPE_PREFERENCE_RELAY_TCP 
ICE_TYPE_PREFERENCE_RELAY_UDP 
ICE_TYPE_PREFERENCE_PRFLX_TCP 
ICE_TYPE_PREFERENCE_HOST_TCP 
ICE_TYPE_PREFERENCE_SRFLX 
ICE_TYPE_PREFERENCE_PRFLX 
ICE_TYPE_PREFERENCE_HOST 
ICE_TYPE_PREFERENCE_RELAY_TLS 
ICE_TYPE_PREFERENCE_RELAY_TCP 
ICE_TYPE_PREFERENCE_RELAY_UDP 
ICE_TYPE_PREFERENCE_PRFLX_TCP 
ICE_TYPE_PREFERENCE_HOST_TCP 
ICE_TYPE_PREFERENCE_SRFLX 
ICE_TYPE_PREFERENCE_PRFLX 
ICE_TYPE_PREFERENCE_HOST 

◆ IceProtocolType [1/2]

enum cricket::IceProtocolType
Enumerator
ICEPROTO_RFC5245 
ICEPROTO_RFC5245 

◆ IceProtocolType [2/2]

enum cricket::IceProtocolType
Enumerator
ICEPROTO_RFC5245 
ICEPROTO_RFC5245 

◆ IceRegatheringReason [1/2]

enum cricket::IceRegatheringReason
strong
Enumerator
NETWORK_CHANGE 
NETWORK_FAILURE 
MAX_VALUE 
NETWORK_CHANGE 
NETWORK_FAILURE 
MAX_VALUE 

◆ IceRegatheringReason [2/2]

enum cricket::IceRegatheringReason
strong
Enumerator
NETWORK_CHANGE 
NETWORK_FAILURE 
MAX_VALUE 
NETWORK_CHANGE 
NETWORK_FAILURE 
MAX_VALUE 

◆ IceRestartState [1/2]

enum cricket::IceRestartState
strong
Enumerator
CONNECTING 
CONNECTED 
DISCONNECTED 
MAX_VALUE 
CONNECTING 
CONNECTED 
DISCONNECTED 
MAX_VALUE 

◆ IceRestartState [2/2]

enum cricket::IceRestartState
strong
Enumerator
CONNECTING 
CONNECTED 
DISCONNECTED 
MAX_VALUE 
CONNECTING 
CONNECTED 
DISCONNECTED 
MAX_VALUE 

◆ IceRole [1/2]

enum cricket::IceRole
Enumerator
ICEROLE_CONTROLLING 
ICEROLE_CONTROLLED 
ICEROLE_UNKNOWN 
ICEROLE_CONTROLLING 
ICEROLE_CONTROLLED 
ICEROLE_UNKNOWN 

◆ IceRole [2/2]

enum cricket::IceRole
Enumerator
ICEROLE_CONTROLLING 
ICEROLE_CONTROLLED 
ICEROLE_UNKNOWN 
ICEROLE_CONTROLLING 
ICEROLE_CONTROLLED 
ICEROLE_UNKNOWN 

◆ IceTransportState [1/2]

enum cricket::IceTransportState
strong
Enumerator
STATE_INIT 
STATE_CONNECTING 
STATE_COMPLETED 
STATE_FAILED 
STATE_INIT 
STATE_CONNECTING 
STATE_COMPLETED 
STATE_FAILED 

◆ IceTransportState [2/2]

enum cricket::IceTransportState
strong
Enumerator
STATE_INIT 
STATE_CONNECTING 
STATE_COMPLETED 
STATE_FAILED 
STATE_INIT 
STATE_CONNECTING 
STATE_COMPLETED 
STATE_FAILED 

◆ MediaContentDirection [1/2]

enum cricket::MediaContentDirection
Enumerator
MD_INACTIVE 
MD_SENDONLY 
MD_RECVONLY 
MD_SENDRECV 
MD_INACTIVE 
MD_SENDONLY 
MD_RECVONLY 
MD_SENDRECV 

◆ MediaContentDirection [2/2]

enum cricket::MediaContentDirection
Enumerator
MD_INACTIVE 
MD_SENDONLY 
MD_RECVONLY 
MD_SENDRECV 
MD_INACTIVE 
MD_SENDONLY 
MD_RECVONLY 
MD_SENDRECV 

◆ MediaType [1/2]

enum cricket::MediaType
Enumerator
MEDIA_TYPE_AUDIO 
MEDIA_TYPE_VIDEO 
MEDIA_TYPE_DATA 
MEDIA_TYPE_AUDIO 
MEDIA_TYPE_VIDEO 
MEDIA_TYPE_DATA 

◆ MediaType [2/2]

enum cricket::MediaType
Enumerator
MEDIA_TYPE_AUDIO 
MEDIA_TYPE_VIDEO 
MEDIA_TYPE_DATA 
MEDIA_TYPE_AUDIO 
MEDIA_TYPE_VIDEO 
MEDIA_TYPE_DATA 

◆ NominationMode [1/2]

enum cricket::NominationMode
strong
Enumerator
REGULAR 
AGGRESSIVE 
SEMI_AGGRESSIVE 
REGULAR 
AGGRESSIVE 
SEMI_AGGRESSIVE 

◆ NominationMode [2/2]

enum cricket::NominationMode
strong
Enumerator
REGULAR 
AGGRESSIVE 
SEMI_AGGRESSIVE 
REGULAR 
AGGRESSIVE 
SEMI_AGGRESSIVE 

◆ PacketFlags [1/2]

enum cricket::PacketFlags
Enumerator
PF_NORMAL 
PF_SRTP_BYPASS 
PF_NORMAL 
PF_SRTP_BYPASS 

◆ PacketFlags [2/2]

enum cricket::PacketFlags
Enumerator
PF_NORMAL 
PF_SRTP_BYPASS 
PF_NORMAL 
PF_SRTP_BYPASS 

◆ ProtocolType [1/2]

enum cricket::ProtocolType
Enumerator
PROTO_UDP 
PROTO_TCP 
PROTO_SSLTCP 
PROTO_TLS 
PROTO_LAST 
PROTO_UDP 
PROTO_TCP 
PROTO_SSLTCP 
PROTO_TLS 
PROTO_LAST 

◆ ProtocolType [2/2]

enum cricket::ProtocolType
Enumerator
PROTO_UDP 
PROTO_TCP 
PROTO_SSLTCP 
PROTO_TLS 
PROTO_LAST 
PROTO_UDP 
PROTO_TCP 
PROTO_SSLTCP 
PROTO_TLS 
PROTO_LAST 

◆ QuicTransportState [1/2]

enum cricket::QuicTransportState
Enumerator
QUIC_TRANSPORT_NEW 
QUIC_TRANSPORT_CONNECTING 
QUIC_TRANSPORT_CONNECTED 
QUIC_TRANSPORT_CLOSED 
QUIC_TRANSPORT_NEW 
QUIC_TRANSPORT_CONNECTING 
QUIC_TRANSPORT_CONNECTED 
QUIC_TRANSPORT_CLOSED 

◆ QuicTransportState [2/2]

enum cricket::QuicTransportState
Enumerator
QUIC_TRANSPORT_NEW 
QUIC_TRANSPORT_CONNECTING 
QUIC_TRANSPORT_CONNECTED 
QUIC_TRANSPORT_CLOSED 
QUIC_TRANSPORT_NEW 
QUIC_TRANSPORT_CONNECTING 
QUIC_TRANSPORT_CONNECTED 
QUIC_TRANSPORT_CLOSED 

◆ RelayAttributeType [1/2]

enum cricket::RelayAttributeType
Enumerator
STUN_ATTR_LIFETIME 
STUN_ATTR_MAGIC_COOKIE 
STUN_ATTR_BANDWIDTH 
STUN_ATTR_DESTINATION_ADDRESS 
STUN_ATTR_SOURCE_ADDRESS2 
STUN_ATTR_DATA 
STUN_ATTR_OPTIONS 
STUN_ATTR_LIFETIME 
STUN_ATTR_MAGIC_COOKIE 
STUN_ATTR_BANDWIDTH 
STUN_ATTR_DESTINATION_ADDRESS 
STUN_ATTR_SOURCE_ADDRESS2 
STUN_ATTR_DATA 
STUN_ATTR_OPTIONS 

◆ RelayAttributeType [2/2]

enum cricket::RelayAttributeType
Enumerator
STUN_ATTR_LIFETIME 
STUN_ATTR_MAGIC_COOKIE 
STUN_ATTR_BANDWIDTH 
STUN_ATTR_DESTINATION_ADDRESS 
STUN_ATTR_SOURCE_ADDRESS2 
STUN_ATTR_DATA 
STUN_ATTR_OPTIONS 
STUN_ATTR_LIFETIME 
STUN_ATTR_MAGIC_COOKIE 
STUN_ATTR_BANDWIDTH 
STUN_ATTR_DESTINATION_ADDRESS 
STUN_ATTR_SOURCE_ADDRESS2 
STUN_ATTR_DATA 
STUN_ATTR_OPTIONS 

◆ RelayMessageType [1/2]

enum cricket::RelayMessageType
Enumerator
STUN_SEND_REQUEST 
STUN_SEND_RESPONSE 
STUN_SEND_ERROR_RESPONSE 
STUN_DATA_INDICATION 
STUN_SEND_REQUEST 
STUN_SEND_RESPONSE 
STUN_SEND_ERROR_RESPONSE 
STUN_DATA_INDICATION 

◆ RelayMessageType [2/2]

enum cricket::RelayMessageType
Enumerator
STUN_SEND_REQUEST 
STUN_SEND_RESPONSE 
STUN_SEND_ERROR_RESPONSE 
STUN_DATA_INDICATION 
STUN_SEND_REQUEST 
STUN_SEND_RESPONSE 
STUN_SEND_ERROR_RESPONSE 
STUN_DATA_INDICATION 

◆ RelayType [1/2]

enum cricket::RelayType
Enumerator
RELAY_GTURN 
RELAY_TURN 
RELAY_GTURN 
RELAY_TURN 

◆ RelayType [2/2]

enum cricket::RelayType
Enumerator
RELAY_GTURN 
RELAY_TURN 
RELAY_GTURN 
RELAY_TURN 

◆ RtcpTypes [1/2]

enum cricket::RtcpTypes
Enumerator
kRtcpTypeSR 
kRtcpTypeRR 
kRtcpTypeSDES 
kRtcpTypeBye 
kRtcpTypeApp 
kRtcpTypeRTPFB 
kRtcpTypePSFB 
kRtcpTypeSR 
kRtcpTypeRR 
kRtcpTypeSDES 
kRtcpTypeBye 
kRtcpTypeApp 
kRtcpTypeRTPFB 
kRtcpTypePSFB 

◆ RtcpTypes [2/2]

enum cricket::RtcpTypes
Enumerator
kRtcpTypeSR 
kRtcpTypeRR 
kRtcpTypeSDES 
kRtcpTypeBye 
kRtcpTypeApp 
kRtcpTypeRTPFB 
kRtcpTypePSFB 
kRtcpTypeSR 
kRtcpTypeRR 
kRtcpTypeSDES 
kRtcpTypeBye 
kRtcpTypeApp 
kRtcpTypeRTPFB 
kRtcpTypePSFB 

◆ SecurePolicy [1/2]

enum cricket::SecurePolicy
Enumerator
SEC_DISABLED 
SEC_ENABLED 
SEC_REQUIRED 
SEC_DISABLED 
SEC_ENABLED 
SEC_REQUIRED 

◆ SecurePolicy [2/2]

enum cricket::SecurePolicy
Enumerator
SEC_DISABLED 
SEC_ENABLED 
SEC_REQUIRED 
SEC_DISABLED 
SEC_ENABLED 
SEC_REQUIRED 

◆ SendDataResult [1/2]

enum cricket::SendDataResult
Enumerator
SDR_SUCCESS 
SDR_ERROR 
SDR_BLOCK 
SDR_SUCCESS 
SDR_ERROR 
SDR_BLOCK 

◆ SendDataResult [2/2]

enum cricket::SendDataResult
Enumerator
SDR_SUCCESS 
SDR_ERROR 
SDR_BLOCK 
SDR_SUCCESS 
SDR_ERROR 
SDR_BLOCK 

◆ SessionState [1/2]

enum cricket::SessionState
strong
Enumerator
GATHERING 
CLEARED 
STOPPED 
GATHERING 
CLEARED 
STOPPED 

◆ SessionState [2/2]

enum cricket::SessionState
strong
Enumerator
GATHERING 
CLEARED 
STOPPED 
GATHERING 
CLEARED 
STOPPED 

◆ StunAddressFamily [1/2]

enum cricket::StunAddressFamily
Enumerator
STUN_ADDRESS_UNDEF 
STUN_ADDRESS_IPV4 
STUN_ADDRESS_IPV6 
STUN_ADDRESS_UNDEF 
STUN_ADDRESS_IPV4 
STUN_ADDRESS_IPV6 

◆ StunAddressFamily [2/2]

enum cricket::StunAddressFamily
Enumerator
STUN_ADDRESS_UNDEF 
STUN_ADDRESS_IPV4 
STUN_ADDRESS_IPV6 
STUN_ADDRESS_UNDEF 
STUN_ADDRESS_IPV4 
STUN_ADDRESS_IPV6 

◆ StunAttributeType [1/2]

enum cricket::StunAttributeType
Enumerator
STUN_ATTR_MAPPED_ADDRESS 
STUN_ATTR_USERNAME 
STUN_ATTR_MESSAGE_INTEGRITY 
STUN_ATTR_ERROR_CODE 
STUN_ATTR_UNKNOWN_ATTRIBUTES 
STUN_ATTR_REALM 
STUN_ATTR_NONCE 
STUN_ATTR_XOR_MAPPED_ADDRESS 
STUN_ATTR_SOFTWARE 
STUN_ATTR_ALTERNATE_SERVER 
STUN_ATTR_FINGERPRINT 
STUN_ATTR_ORIGIN 
STUN_ATTR_RETRANSMIT_COUNT 
STUN_ATTR_MAPPED_ADDRESS 
STUN_ATTR_USERNAME 
STUN_ATTR_MESSAGE_INTEGRITY 
STUN_ATTR_ERROR_CODE 
STUN_ATTR_UNKNOWN_ATTRIBUTES 
STUN_ATTR_REALM 
STUN_ATTR_NONCE 
STUN_ATTR_XOR_MAPPED_ADDRESS 
STUN_ATTR_SOFTWARE 
STUN_ATTR_ALTERNATE_SERVER 
STUN_ATTR_FINGERPRINT 
STUN_ATTR_ORIGIN 
STUN_ATTR_RETRANSMIT_COUNT 

◆ StunAttributeType [2/2]

enum cricket::StunAttributeType
Enumerator
STUN_ATTR_MAPPED_ADDRESS 
STUN_ATTR_USERNAME 
STUN_ATTR_MESSAGE_INTEGRITY 
STUN_ATTR_ERROR_CODE 
STUN_ATTR_UNKNOWN_ATTRIBUTES 
STUN_ATTR_REALM 
STUN_ATTR_NONCE 
STUN_ATTR_XOR_MAPPED_ADDRESS 
STUN_ATTR_SOFTWARE 
STUN_ATTR_ALTERNATE_SERVER 
STUN_ATTR_FINGERPRINT 
STUN_ATTR_ORIGIN 
STUN_ATTR_RETRANSMIT_COUNT 
STUN_ATTR_MAPPED_ADDRESS 
STUN_ATTR_USERNAME 
STUN_ATTR_MESSAGE_INTEGRITY 
STUN_ATTR_ERROR_CODE 
STUN_ATTR_UNKNOWN_ATTRIBUTES 
STUN_ATTR_REALM 
STUN_ATTR_NONCE 
STUN_ATTR_XOR_MAPPED_ADDRESS 
STUN_ATTR_SOFTWARE 
STUN_ATTR_ALTERNATE_SERVER 
STUN_ATTR_FINGERPRINT 
STUN_ATTR_ORIGIN 
STUN_ATTR_RETRANSMIT_COUNT 

◆ StunAttributeValueType [1/2]

enum cricket::StunAttributeValueType
Enumerator
STUN_VALUE_UNKNOWN 
STUN_VALUE_ADDRESS 
STUN_VALUE_XOR_ADDRESS 
STUN_VALUE_UINT32 
STUN_VALUE_UINT64 
STUN_VALUE_BYTE_STRING 
STUN_VALUE_ERROR_CODE 
STUN_VALUE_UINT16_LIST 
STUN_VALUE_UNKNOWN 
STUN_VALUE_ADDRESS 
STUN_VALUE_XOR_ADDRESS 
STUN_VALUE_UINT32 
STUN_VALUE_UINT64 
STUN_VALUE_BYTE_STRING 
STUN_VALUE_ERROR_CODE 
STUN_VALUE_UINT16_LIST 

◆ StunAttributeValueType [2/2]

enum cricket::StunAttributeValueType
Enumerator
STUN_VALUE_UNKNOWN 
STUN_VALUE_ADDRESS 
STUN_VALUE_XOR_ADDRESS 
STUN_VALUE_UINT32 
STUN_VALUE_UINT64 
STUN_VALUE_BYTE_STRING 
STUN_VALUE_ERROR_CODE 
STUN_VALUE_UINT16_LIST 
STUN_VALUE_UNKNOWN 
STUN_VALUE_ADDRESS 
STUN_VALUE_XOR_ADDRESS 
STUN_VALUE_UINT32 
STUN_VALUE_UINT64 
STUN_VALUE_BYTE_STRING 
STUN_VALUE_ERROR_CODE 
STUN_VALUE_UINT16_LIST 

◆ StunErrorCode [1/2]

enum cricket::StunErrorCode
Enumerator
STUN_ERROR_TRY_ALTERNATE 
STUN_ERROR_BAD_REQUEST 
STUN_ERROR_UNAUTHORIZED 
STUN_ERROR_UNKNOWN_ATTRIBUTE 
STUN_ERROR_STALE_CREDENTIALS 
STUN_ERROR_STALE_NONCE 
STUN_ERROR_SERVER_ERROR 
STUN_ERROR_GLOBAL_FAILURE 
STUN_ERROR_TRY_ALTERNATE 
STUN_ERROR_BAD_REQUEST 
STUN_ERROR_UNAUTHORIZED 
STUN_ERROR_UNKNOWN_ATTRIBUTE 
STUN_ERROR_STALE_CREDENTIALS 
STUN_ERROR_STALE_NONCE 
STUN_ERROR_SERVER_ERROR 
STUN_ERROR_GLOBAL_FAILURE 

◆ StunErrorCode [2/2]

enum cricket::StunErrorCode
Enumerator
STUN_ERROR_TRY_ALTERNATE 
STUN_ERROR_BAD_REQUEST 
STUN_ERROR_UNAUTHORIZED 
STUN_ERROR_UNKNOWN_ATTRIBUTE 
STUN_ERROR_STALE_CREDENTIALS 
STUN_ERROR_STALE_NONCE 
STUN_ERROR_SERVER_ERROR 
STUN_ERROR_GLOBAL_FAILURE 
STUN_ERROR_TRY_ALTERNATE 
STUN_ERROR_BAD_REQUEST 
STUN_ERROR_UNAUTHORIZED 
STUN_ERROR_UNKNOWN_ATTRIBUTE 
STUN_ERROR_STALE_CREDENTIALS 
STUN_ERROR_STALE_NONCE 
STUN_ERROR_SERVER_ERROR 
STUN_ERROR_GLOBAL_FAILURE 

◆ StunMessageType [1/2]

enum cricket::StunMessageType
Enumerator
STUN_BINDING_REQUEST 
STUN_BINDING_INDICATION 
STUN_BINDING_RESPONSE 
STUN_BINDING_ERROR_RESPONSE 
STUN_BINDING_REQUEST 
STUN_BINDING_INDICATION 
STUN_BINDING_RESPONSE 
STUN_BINDING_ERROR_RESPONSE 

◆ StunMessageType [2/2]

enum cricket::StunMessageType
Enumerator
STUN_BINDING_REQUEST 
STUN_BINDING_INDICATION 
STUN_BINDING_RESPONSE 
STUN_BINDING_ERROR_RESPONSE 
STUN_BINDING_REQUEST 
STUN_BINDING_INDICATION 
STUN_BINDING_RESPONSE 
STUN_BINDING_ERROR_RESPONSE 

◆ TlsCertPolicy [1/2]

enum cricket::TlsCertPolicy
strong
Enumerator
TLS_CERT_POLICY_SECURE 
TLS_CERT_POLICY_INSECURE_NO_CHECK 
TLS_CERT_POLICY_SECURE 
TLS_CERT_POLICY_INSECURE_NO_CHECK 

◆ TlsCertPolicy [2/2]

enum cricket::TlsCertPolicy
strong
Enumerator
TLS_CERT_POLICY_SECURE 
TLS_CERT_POLICY_INSECURE_NO_CHECK 
TLS_CERT_POLICY_SECURE 
TLS_CERT_POLICY_INSECURE_NO_CHECK 

◆ TurnAttributeType [1/2]

enum cricket::TurnAttributeType
Enumerator
STUN_ATTR_CHANNEL_NUMBER 
STUN_ATTR_TURN_LIFETIME 
STUN_ATTR_XOR_PEER_ADDRESS 
STUN_ATTR_XOR_RELAYED_ADDRESS 
STUN_ATTR_EVEN_PORT 
STUN_ATTR_REQUESTED_TRANSPORT 
STUN_ATTR_DONT_FRAGMENT 
STUN_ATTR_RESERVATION_TOKEN 
STUN_ATTR_CHANNEL_NUMBER 
STUN_ATTR_TURN_LIFETIME 
STUN_ATTR_XOR_PEER_ADDRESS 
STUN_ATTR_XOR_RELAYED_ADDRESS 
STUN_ATTR_EVEN_PORT 
STUN_ATTR_REQUESTED_TRANSPORT 
STUN_ATTR_DONT_FRAGMENT 
STUN_ATTR_RESERVATION_TOKEN 

◆ TurnAttributeType [2/2]

enum cricket::TurnAttributeType
Enumerator
STUN_ATTR_CHANNEL_NUMBER 
STUN_ATTR_TURN_LIFETIME 
STUN_ATTR_XOR_PEER_ADDRESS 
STUN_ATTR_XOR_RELAYED_ADDRESS 
STUN_ATTR_EVEN_PORT 
STUN_ATTR_REQUESTED_TRANSPORT 
STUN_ATTR_DONT_FRAGMENT 
STUN_ATTR_RESERVATION_TOKEN 
STUN_ATTR_CHANNEL_NUMBER 
STUN_ATTR_TURN_LIFETIME 
STUN_ATTR_XOR_PEER_ADDRESS 
STUN_ATTR_XOR_RELAYED_ADDRESS 
STUN_ATTR_EVEN_PORT 
STUN_ATTR_REQUESTED_TRANSPORT 
STUN_ATTR_DONT_FRAGMENT 
STUN_ATTR_RESERVATION_TOKEN 

◆ TurnErrorType [1/2]

enum cricket::TurnErrorType
Enumerator
STUN_ERROR_FORBIDDEN 
STUN_ERROR_ALLOCATION_MISMATCH 
STUN_ERROR_WRONG_CREDENTIALS 
STUN_ERROR_UNSUPPORTED_PROTOCOL 
STUN_ERROR_FORBIDDEN 
STUN_ERROR_ALLOCATION_MISMATCH 
STUN_ERROR_WRONG_CREDENTIALS 
STUN_ERROR_UNSUPPORTED_PROTOCOL 

◆ TurnErrorType [2/2]

enum cricket::TurnErrorType
Enumerator
STUN_ERROR_FORBIDDEN 
STUN_ERROR_ALLOCATION_MISMATCH 
STUN_ERROR_WRONG_CREDENTIALS 
STUN_ERROR_UNSUPPORTED_PROTOCOL 
STUN_ERROR_FORBIDDEN 
STUN_ERROR_ALLOCATION_MISMATCH 
STUN_ERROR_WRONG_CREDENTIALS 
STUN_ERROR_UNSUPPORTED_PROTOCOL 

◆ TurnMessageType [1/2]

enum cricket::TurnMessageType
Enumerator
STUN_ALLOCATE_REQUEST 
STUN_ALLOCATE_RESPONSE 
STUN_ALLOCATE_ERROR_RESPONSE 
TURN_REFRESH_REQUEST 
TURN_REFRESH_RESPONSE 
TURN_REFRESH_ERROR_RESPONSE 
TURN_SEND_INDICATION 
TURN_DATA_INDICATION 
TURN_CREATE_PERMISSION_REQUEST 
TURN_CREATE_PERMISSION_RESPONSE 
TURN_CREATE_PERMISSION_ERROR_RESPONSE 
TURN_CHANNEL_BIND_REQUEST 
TURN_CHANNEL_BIND_RESPONSE 
TURN_CHANNEL_BIND_ERROR_RESPONSE 
STUN_ALLOCATE_REQUEST 
STUN_ALLOCATE_RESPONSE 
STUN_ALLOCATE_ERROR_RESPONSE 
TURN_REFRESH_REQUEST 
TURN_REFRESH_RESPONSE 
TURN_REFRESH_ERROR_RESPONSE 
TURN_SEND_INDICATION 
TURN_DATA_INDICATION 
TURN_CREATE_PERMISSION_REQUEST 
TURN_CREATE_PERMISSION_RESPONSE 
TURN_CREATE_PERMISSION_ERROR_RESPONSE 
TURN_CHANNEL_BIND_REQUEST 
TURN_CHANNEL_BIND_RESPONSE 
TURN_CHANNEL_BIND_ERROR_RESPONSE 

◆ TurnMessageType [2/2]

enum cricket::TurnMessageType
Enumerator
STUN_ALLOCATE_REQUEST 
STUN_ALLOCATE_RESPONSE 
STUN_ALLOCATE_ERROR_RESPONSE 
TURN_REFRESH_REQUEST 
TURN_REFRESH_RESPONSE 
TURN_REFRESH_ERROR_RESPONSE 
TURN_SEND_INDICATION 
TURN_DATA_INDICATION 
TURN_CREATE_PERMISSION_REQUEST 
TURN_CREATE_PERMISSION_RESPONSE 
TURN_CREATE_PERMISSION_ERROR_RESPONSE 
TURN_CHANNEL_BIND_REQUEST 
TURN_CHANNEL_BIND_RESPONSE 
TURN_CHANNEL_BIND_ERROR_RESPONSE 
STUN_ALLOCATE_REQUEST 
STUN_ALLOCATE_RESPONSE 
STUN_ALLOCATE_ERROR_RESPONSE 
TURN_REFRESH_REQUEST 
TURN_REFRESH_RESPONSE 
TURN_REFRESH_ERROR_RESPONSE 
TURN_SEND_INDICATION 
TURN_DATA_INDICATION 
TURN_CREATE_PERMISSION_REQUEST 
TURN_CREATE_PERMISSION_RESPONSE 
TURN_CREATE_PERMISSION_ERROR_RESPONSE 
TURN_CHANNEL_BIND_REQUEST 
TURN_CHANNEL_BIND_RESPONSE 
TURN_CHANNEL_BIND_ERROR_RESPONSE 

Function Documentation

◆ ApplyPacketOptions()

bool cricket::ApplyPacketOptions ( uint8_t *  data,
size_t  length,
const rtc::PacketTimeUpdateParams &  packet_time_params,
uint64_t  time_us 
)

◆ AudioCodecToSdpAudioFormat()

webrtc::SdpAudioFormat cricket::AudioCodecToSdpAudioFormat ( const AudioCodec &  ac)

◆ BadTransportDescription()

bool cricket::BadTransportDescription ( const std::string &  desc,
std::string *  err_desc 
)

◆ bound()

uint32_t cricket::bound ( uint32_t  lower,
uint32_t  middle,
uint32_t  upper 
)

◆ bytes_to_long()

uint32_t cricket::bytes_to_long ( const void *  buf)
inline

◆ bytes_to_short()

uint16_t cricket::bytes_to_short ( const void *  buf)
inline

◆ CanonicalFourCC()

uint32_t cricket::CanonicalFourCC ( uint32_t  fourcc)

◆ CheckFailureToRead()

void cricket::CheckFailureToRead ( const unsigned char *  testcase,
size_t  length 
)

◆ CodecNamesEq() [1/2]

bool cricket::CodecNamesEq ( const std::string &  name1,
const std::string &  name2 
)

◆ CodecNamesEq() [2/2]

bool cricket::CodecNamesEq ( const char *  name1,
const char *  name2 
)

◆ CompareDtmfInfo()

bool cricket::CompareDtmfInfo ( const FakeVoiceMediaChannel::DtmfInfo &  info,
uint32_t  ssrc,
int  event_code,
int  duration 
)
inline

◆ ComputeStunCredentialHash()

bool cricket::ComputeStunCredentialHash ( const std::string &  username,
const std::string &  realm,
const std::string &  password,
std::string *  hash 
)

◆ ConnectionRoleToString()

bool cricket::ConnectionRoleToString ( const ConnectionRole &  role,
std::string *  role_str 
)

◆ ContainsMatchingCodec()

template<class C >
bool cricket::ContainsMatchingCodec ( const std::vector< C > &  codecs,
const C &  codec 
)

◆ CreatePrimaryWithFecFrStreamParams()

cricket::StreamParams cricket::CreatePrimaryWithFecFrStreamParams ( const std::string &  cname,
uint32_t  primary_ssrc,
uint32_t  flexfec_ssrc 
)

◆ CreateRtpParametersWithOneEncoding()

webrtc::RtpParameters cricket::CreateRtpParametersWithOneEncoding ( )

◆ CreateSimStreamParams()

cricket::StreamParams cricket::CreateSimStreamParams ( const std::string &  cname,
const std::vector< uint32_t > &  ssrcs 
)

◆ CreateSimWithRtxStreamParams()

cricket::StreamParams cricket::CreateSimWithRtxStreamParams ( const std::string &  cname,
const std::vector< uint32_t > &  ssrcs,
const std::vector< uint32_t > &  rtx_ssrcs 
)

◆ FilterDataCodecs()

void cricket::FilterDataCodecs ( std::vector< DataCodec > *  codecs,
bool  sctp 
)

◆ FilterRtpExtensions()

std::vector< webrtc::RtpExtension > cricket::FilterRtpExtensions ( const std::vector< webrtc::RtpExtension > &  extensions,
bool(*)(const std::string &)  supported,
bool  filter_redundant_extensions 
)

◆ FindCodecById()

template<class Codec >
const Codec * cricket::FindCodecById ( const std::vector< Codec > &  codecs,
int  payload_type 
)

◆ FindContentInfoByName() [1/2]

ContentInfo* cricket::FindContentInfoByName ( ContentInfos &  contents,
const std::string &  name 
)

◆ FindContentInfoByName() [2/2]

const ContentInfo * cricket::FindContentInfoByName ( const ContentInfos &  contents,
const std::string &  name 
)

◆ FindContentInfoByType()

const ContentInfo * cricket::FindContentInfoByType ( const ContentInfos &  contents,
const std::string &  type 
)

◆ FindKnownCodec()

const DataCodec* cricket::FindKnownCodec ( const std::vector< DataCodec > &  codecs)

◆ FindMatchingCodec()

const VideoCodec * cricket::FindMatchingCodec ( const std::vector< VideoCodec > &  supported_codecs,
const VideoCodec &  codec 
)

◆ FindMatchingCrypto()

bool cricket::FindMatchingCrypto ( const CryptoParamsVec &  cryptos,
const CryptoParams &  crypto,
CryptoParams *  out 
)

◆ FindSimulcastFormatIndex() [1/2]

int cricket::FindSimulcastFormatIndex ( int  width,
int  height 
)

◆ FindSimulcastFormatIndex() [2/2]

int cricket::FindSimulcastFormatIndex ( int  width,
int  height,
size_t  max_layers 
)

◆ FindSimulcastMaxBitrateBps()

int cricket::FindSimulcastMaxBitrateBps ( int  width,
int  height 
)

◆ FindSimulcastMaxLayers()

size_t cricket::FindSimulcastMaxLayers ( int  width,
int  height 
)

◆ FindSimulcastMinBitrateBps()

int cricket::FindSimulcastMinBitrateBps ( int  width,
int  height 
)

◆ FindSimulcastTargetBitrateBps()

int cricket::FindSimulcastTargetBitrateBps ( int  width,
int  height 
)

◆ FindUnknownCodec()

const DataCodec* cricket::FindUnknownCodec ( const std::vector< DataCodec > &  codecs)

◆ GetBitrateConfigForCodec()

webrtc::Call::Config::BitrateConfig cricket::GetBitrateConfigForCodec ( const Codec &  codec)

◆ GetCryptos()

const CryptoParamsVec* cricket::GetCryptos ( const MediaContentDescription *  media)

◆ GetDefaultSrtpCryptoSuiteNames()

void cricket::GetDefaultSrtpCryptoSuiteNames ( const rtc::CryptoOptions &  crypto_options,
std::vector< std::string > *  crypto_suite_names 
)

◆ GetDefaultSrtpCryptoSuites()

void cricket::GetDefaultSrtpCryptoSuites ( const rtc::CryptoOptions &  crypto_options,
std::vector< int > *  crypto_suites 
)

◆ GetFirstAudioContent() [1/4]

const ContentInfo * cricket::GetFirstAudioContent ( const ContentInfos &  contents)

◆ GetFirstAudioContent() [2/4]

const ContentInfo * cricket::GetFirstAudioContent ( const SessionDescription *  sdesc)

◆ GetFirstAudioContent() [3/4]

ContentInfo * cricket::GetFirstAudioContent ( ContentInfos &  contents)

◆ GetFirstAudioContent() [4/4]

ContentInfo * cricket::GetFirstAudioContent ( SessionDescription *  sdesc)

◆ GetFirstAudioContentDescription() [1/2]

const AudioContentDescription * cricket::GetFirstAudioContentDescription ( const SessionDescription *  sdesc)

◆ GetFirstAudioContentDescription() [2/2]

AudioContentDescription * cricket::GetFirstAudioContentDescription ( SessionDescription *  sdesc)

◆ GetFirstDataContent() [1/4]

const ContentInfo * cricket::GetFirstDataContent ( const ContentInfos &  contents)

◆ GetFirstDataContent() [2/4]

const ContentInfo * cricket::GetFirstDataContent ( const SessionDescription *  sdesc)

◆ GetFirstDataContent() [3/4]

ContentInfo * cricket::GetFirstDataContent ( ContentInfos &  contents)

◆ GetFirstDataContent() [4/4]

ContentInfo * cricket::GetFirstDataContent ( SessionDescription *  sdesc)

◆ GetFirstDataContentDescription() [1/2]

const DataContentDescription * cricket::GetFirstDataContentDescription ( const SessionDescription *  sdesc)

◆ GetFirstDataContentDescription() [2/2]

DataContentDescription * cricket::GetFirstDataContentDescription ( SessionDescription *  sdesc)

◆ GetFirstMediaContent() [1/2]

const ContentInfo * cricket::GetFirstMediaContent ( const ContentInfos &  contents,
MediaType  media_type 
)

◆ GetFirstMediaContent() [2/2]

ContentInfo * cricket::GetFirstMediaContent ( ContentInfos &  contents,
MediaType  media_type 
)

◆ GetFirstMediaContentDescription() [1/2]

const MediaContentDescription* cricket::GetFirstMediaContentDescription ( const SessionDescription *  sdesc,
MediaType  media_type 
)

◆ GetFirstMediaContentDescription() [2/2]

MediaContentDescription* cricket::GetFirstMediaContentDescription ( SessionDescription *  sdesc,
MediaType  media_type 
)

◆ GetFirstVideoContent() [1/4]

const ContentInfo * cricket::GetFirstVideoContent ( const ContentInfos &  contents)

◆ GetFirstVideoContent() [2/4]

const ContentInfo * cricket::GetFirstVideoContent ( const SessionDescription *  sdesc)

◆ GetFirstVideoContent() [3/4]

ContentInfo * cricket::GetFirstVideoContent ( ContentInfos &  contents)

◆ GetFirstVideoContent() [4/4]

ContentInfo * cricket::GetFirstVideoContent ( SessionDescription *  sdesc)

◆ GetFirstVideoContentDescription() [1/2]

const VideoContentDescription * cricket::GetFirstVideoContentDescription ( const SessionDescription *  sdesc)

◆ GetFirstVideoContentDescription() [2/2]

VideoContentDescription * cricket::GetFirstVideoContentDescription ( SessionDescription *  sdesc)

◆ GetFourccName()

std::string cricket::GetFourccName ( uint32_t  fourcc)
inline

◆ GetRtcpSsrc()

bool cricket::GetRtcpSsrc ( const void *  data,
size_t  len,
uint32_t *  value 
)

◆ GetRtcpType()

bool cricket::GetRtcpType ( const void *  data,
size_t  len,
int *  value 
)

◆ GetRtpFlags()

bool cricket::GetRtpFlags ( const void *  data,
size_t  len,
int *  value 
)

◆ GetRtpHeader()

bool cricket::GetRtpHeader ( const void *  data,
size_t  len,
RtpHeader *  header 
)

◆ GetRtpHeaderLen()

bool cricket::GetRtpHeaderLen ( const void *  data,
size_t  len,
size_t *  value 
)

◆ GetRtpPayloadType()

bool cricket::GetRtpPayloadType ( const void *  data,
size_t  len,
int *  value 
)

◆ GetRtpSeqNum()

bool cricket::GetRtpSeqNum ( const void *  data,
size_t  len,
int *  value 
)

◆ GetRtpSsrc()

bool cricket::GetRtpSsrc ( const void *  data,
size_t  len,
uint32_t *  value 
)

◆ GetRtpTimestamp()

bool cricket::GetRtpTimestamp ( const void *  data,
size_t  len,
uint32_t *  value 
)

◆ GetSimulcastConfig()

std::vector< webrtc::VideoStream > cricket::GetSimulcastConfig ( size_t  max_streams,
int  width,
int  height,
int  max_bitrate_bps,
int  max_qp,
int  max_framerate,
bool  is_screencast = false 
)

◆ GetSimulcastSsrcs()

void cricket::GetSimulcastSsrcs ( const StreamParams &  sp,
std::vector< uint32_t > *  ssrcs 
)

◆ GetStream() [1/3]

bool cricket::GetStream ( const StreamParamsVec &  streams,
const StreamSelector &  selector,
StreamParams *  stream_out 
)

◆ GetStream() [2/3]

template<class Condition >
const StreamParams * cricket::GetStream ( const StreamParamsVec &  streams,
Condition  condition 
)

◆ GetStream() [3/3]

const StreamParams * cricket::GetStream ( const StreamParamsVec &  streams,
const StreamSelector &  selector 
)
inline

◆ GetStreamByIds()

const StreamParams * cricket::GetStreamByIds ( const StreamParamsVec &  streams,
const std::string &  groupid,
const std::string &  id 
)
inline

◆ GetStreamBySsrc()

const StreamParams * cricket::GetStreamBySsrc ( const StreamParamsVec &  streams,
uint32_t  ssrc 
)
inline

◆ GetStunErrorResponseType()

int cricket::GetStunErrorResponseType ( int  request_type)

◆ GetStunSuccessResponseType()

int cricket::GetStunSuccessResponseType ( int  request_type)

◆ GetSupportedAudioCryptoSuiteNames()

void cricket::GetSupportedAudioCryptoSuiteNames ( const rtc::CryptoOptions &  crypto_options,
std::vector< std::string > *  crypto_suite_names 
)

◆ GetSupportedAudioCryptoSuites()

void cricket::GetSupportedAudioCryptoSuites ( const rtc::CryptoOptions &  crypto_options,
std::vector< int > *  crypto_suites 
)

◆ GetSupportedDataCryptoSuiteNames()

void cricket::GetSupportedDataCryptoSuiteNames ( const rtc::CryptoOptions &  crypto_options,
std::vector< std::string > *  crypto_suite_names 
)

◆ GetSupportedDataCryptoSuites()

void cricket::GetSupportedDataCryptoSuites ( const rtc::CryptoOptions &  crypto_options,
std::vector< int > *  crypto_suites 
)

◆ GetSupportedVideoCryptoSuiteNames()

void cricket::GetSupportedVideoCryptoSuiteNames ( const rtc::CryptoOptions &  crypto_options,
std::vector< std::string > *  crypto_suite_names 
)

◆ GetSupportedVideoCryptoSuites()

void cricket::GetSupportedVideoCryptoSuites ( const rtc::CryptoOptions &  crypto_options,
std::vector< int > *  crypto_suites 
)

◆ GetTotalMaxBitrateBps()

int cricket::GetTotalMaxBitrateBps ( const std::vector< webrtc::VideoStream > &  streams)

◆ GetUint16()

bool cricket::GetUint16 ( const void *  data,
size_t  offset,
int *  value 
)

◆ GetUint32()

bool cricket::GetUint32 ( const void *  data,
size_t  offset,
uint32_t *  value 
)

◆ GetUint8()

bool cricket::GetUint8 ( const void *  data,
size_t  offset,
int *  value 
)

◆ HasNack()

bool cricket::HasNack ( const Codec &  codec)

◆ HasRemb()

bool cricket::HasRemb ( const Codec &  codec)

◆ HasTransportCc()

bool cricket::HasTransportCc ( const Codec &  codec)

◆ IceCredentialsChanged()

bool cricket::IceCredentialsChanged ( const std::string &  old_ufrag,
const std::string &  old_pwd,
const std::string &  new_ufrag,
const std::string &  new_pwd 
)

◆ IsAudioContent()

bool cricket::IsAudioContent ( const ContentInfo *  content)

◆ IsDataContent()

bool cricket::IsDataContent ( const ContentInfo *  content)

◆ IsMediaContent()

bool cricket::IsMediaContent ( const ContentInfo *  content)

◆ IsOneSsrcStream()

bool cricket::IsOneSsrcStream ( const StreamParams &  sp)

◆ IsRtcp()

bool cricket::IsRtcp ( const char *  data,
int  len 
)

◆ IsRtpPacket()

bool cricket::IsRtpPacket ( const void *  data,
size_t  len 
)

◆ IsSimulcastStream()

bool cricket::IsSimulcastStream ( const StreamParams &  sp)

◆ IsStunErrorResponseType()

bool cricket::IsStunErrorResponseType ( int  msg_type)

◆ IsStunIndicationType()

bool cricket::IsStunIndicationType ( int  msg_type)

◆ IsStunMessage()

bool cricket::IsStunMessage ( uint16_t  msg_type)
inline

◆ IsStunRequestType()

bool cricket::IsStunRequestType ( int  msg_type)

◆ IsStunSuccessResponseType()

bool cricket::IsStunSuccessResponseType ( int  msg_type)

◆ IsTurnChannelData()

bool cricket::IsTurnChannelData ( uint16_t  msg_type)
inline

◆ IsValidRtpPayloadType()

bool cricket::IsValidRtpPayloadType ( int  payload_type)

◆ IsVideoContent()

bool cricket::IsVideoContent ( const ContentInfo *  content)

◆ long_to_bytes()

void cricket::long_to_bytes ( uint32_t  val,
void *  buf 
)
inline

◆ MakeVector()

template<class T >
std::vector< T > cricket::MakeVector ( const T  a[],
size_t  s 
)
inline

◆ MaybeExchangeWidthHeight()

void cricket::MaybeExchangeWidthHeight ( int *  width,
int *  height 
)

◆ MediaContentDirectionToString()

std::string cricket::MediaContentDirectionToString ( MediaContentDirection  direction)

◆ MediaTypeFromString()

MediaType cricket::MediaTypeFromString ( const std::string &  type_str)

◆ MediaTypeToString()

std::string cricket::MediaTypeToString ( MediaType  type)

◆ NegotiateRtpTransceiverDirection()

RtpTransceiverDirection cricket::NegotiateRtpTransceiverDirection ( RtpTransceiverDirection  offer,
RtpTransceiverDirection  wants 
)

◆ NormalizeSimulcastSize()

int cricket::NormalizeSimulcastSize ( int  size,
size_t  simulcast_layers 
)

◆ operator<<() [1/2]

std::ostream& cricket::operator<< ( std::ostream &  os,
const std::vector< Candidate > &  candidates 
)

◆ operator<<() [2/2]

std::ostream & cricket::operator<< ( std::ostream &  os,
const AudioCodec &  ac 
)
inline

◆ ProtoToString()

const char * cricket::ProtoToString ( ProtocolType  proto)

◆ RemoveStream() [1/2]

template<class Condition >
bool cricket::RemoveStream ( StreamParamsVec *  streams,
Condition  condition 
)

◆ RemoveStream() [2/2]

bool cricket::RemoveStream ( StreamParamsVec *  streams,
const StreamSelector &  selector 
)
inline

◆ RemoveStreamByIds()

bool cricket::RemoveStreamByIds ( StreamParamsVec *  streams,
const std::string &  groupid,
const std::string &  id 
)
inline

◆ RemoveStreamBySsrc()

bool cricket::RemoveStreamBySsrc ( StreamParamsVec *  streams,
uint32_t  ssrc 
)
inline

◆ RtpParametersFromMediaDescription()

template<class Codec >
void cricket::RtpParametersFromMediaDescription ( const MediaContentDescriptionImpl< Codec > *  desc,
RtpParameters< Codec > *  params 
)

◆ RtpSendParametersFromMediaDescription()

template<class Codec >
void cricket::RtpSendParametersFromMediaDescription ( const MediaContentDescriptionImpl< Codec > *  desc,
RtpSendParameters< Codec > *  send_params 
)

◆ Send()

void cricket::Send ( rtc::AsyncPacketSocket *  socket,
const char *  bytes,
size_t  size,
const rtc::SocketAddress &  addr 
)

◆ SendStun()

void cricket::SendStun ( const StunMessage &  msg,
rtc::AsyncPacketSocket *  socket,
const rtc::SocketAddress &  addr 
)

◆ SendStunError()

void cricket::SendStunError ( const StunMessage &  msg,
rtc::AsyncPacketSocket *  socket,
const rtc::SocketAddress &  remote_addr,
int  error_code,
const char *  error_desc,
const std::string &  magic_cookie 
)

◆ SetRtpHeader()

bool cricket::SetRtpHeader ( void *  data,
size_t  len,
const RtpHeader &  header 
)

◆ SetRtpSsrc()

bool cricket::SetRtpSsrc ( void *  data,
size_t  len,
uint32_t  value 
)

◆ SetUint16()

bool cricket::SetUint16 ( void *  data,
size_t  offset,
uint16_t  value 
)

◆ SetUint32()

bool cricket::SetUint32 ( void *  data,
size_t  offset,
uint32_t  value 
)

◆ SetUint8()

bool cricket::SetUint8 ( void *  data,
size_t  offset,
uint8_t  value 
)

◆ short_to_bytes()

void cricket::short_to_bytes ( uint16_t  val,
void *  buf 
)
inline

◆ ShutdownSrtp()

void cricket::ShutdownSrtp ( )

◆ SlotSimulcastMaxResolution()

bool cricket::SlotSimulcastMaxResolution ( size_t  max_layers,
int *  width,
int *  height 
)

◆ StringToConnectionRole()

bool cricket::StringToConnectionRole ( const std::string &  role_str,
ConnectionRole *  role 
)

◆ StringToProto()

bool cricket::StringToProto ( const char *  value,
ProtocolType *  proto 
)

◆ TEST() [1/40]

cricket::TEST ( VideoCommonTest  ,
TestCanonicalFourCC   
)

◆ TEST() [2/40]

cricket::TEST ( TurnUtilsTest  ,
InvalidTurnSendIndicationMessages   
)

◆ TEST() [3/40]

cricket::TEST ( NullWebRtcVideoEngineTest  ,
CheckInterface   
)

◆ TEST() [4/40]

cricket::TEST ( VideoCommonTest  ,
TestVideoFormatFps   
)

◆ TEST() [5/40]

cricket::TEST ( VideoCommonTest  ,
TestVideoFormatIsSize0x0   
)

◆ TEST() [6/40]

cricket::TEST ( VideoCommonTest  ,
TestVideoFormatToString   
)

◆ TEST() [7/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
ValidateRtpExtensions_EmptyList   
)

◆ TEST() [8/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
ValidateRtpExtensions_AllGood   
)

◆ TEST() [9/40]

cricket::TEST ( TurnUtilsTest  ,
ValidTurnSendIndicationMessage   
)

◆ TEST() [10/40]

cricket::TEST ( VideoCommonTest  ,
TestVideoFormatCompare   
)

◆ TEST() [11/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
ValidateRtpExtensions_OutOfRangeId_Low   
)

◆ TEST() [12/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
ValidateRtpExtensions_OutOfRangeId_High   
)

◆ TEST() [13/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
ValidateRtpExtensions_OverlappingIds_StartOfSet   
)

◆ TEST() [14/40]

cricket::TEST ( RtpUtilsTest  ,
GetRtp   
)

◆ TEST() [15/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
ValidateRtpExtensions_OverlappingIds_EndOfSet   
)

◆ TEST() [16/40]

cricket::TEST ( TurnUtilsTest  ,
ValidTurnChannelMessages   
)

◆ TEST() [17/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
FilterRtpExtensions_EmptyList   
)

◆ TEST() [18/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
FilterRtpExtensions_IncludeOnlySupported   
)

◆ TEST() [19/40]

cricket::TEST ( TurnUtilsTest  ,
ChannelMessageZeroLength   
)

◆ TEST() [20/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
FilterRtpExtensions_SortedByName_1   
)

◆ TEST() [21/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
FilterRtpExtensions_SortedByName_2   
)

◆ TEST() [22/40]

cricket::TEST ( RtpUtilsTest  ,
SetRtpHeader   
)

◆ TEST() [23/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
FilterRtpExtensions_DontRemoveRedundant   
)

◆ TEST() [24/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
FilterRtpExtensions_RemoveRedundant   
)

◆ TEST() [25/40]

cricket::TEST ( RtpUtilsTest  ,
GetRtpHeaderLen   
)

◆ TEST() [26/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
FilterRtpExtensions_RemoveRedundantBwe_1   
)

◆ TEST() [27/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
FilterRtpExtensions_RemoveRedundantBwe_2   
)

◆ TEST() [28/40]

cricket::TEST ( RtpUtilsTest  ,
GetRtcp   
)

◆ TEST() [29/40]

cricket::TEST ( WebRtcMediaEngineTest  ,
FilterRtpExtensions_RemoveRedundantBwe_3   
)

◆ TEST() [30/40]

cricket::TEST ( WebRtcMediaEngineFactoryTest  ,
CreateOldApi   
)

◆ TEST() [31/40]

cricket::TEST ( RtpUtilsTest  ,
InvalidRtpHeader   
)

◆ TEST() [32/40]

cricket::TEST ( WebRtcMediaEngineFactoryTest  ,
CreateWithBuiltinDecoders   
)

◆ TEST() [33/40]

cricket::TEST ( RtpUtilsTest  ,
Valid2ByteExtnHdrRtpMessage   
)

◆ TEST() [34/40]

cricket::TEST ( RtpUtilsTest  ,
ValidRtpPacketWithAbsSendTimeExtension   
)

◆ TEST() [35/40]

cricket::TEST ( RtpUtilsTest  ,
UpdateAbsSendTimeExtensionIn2ByteHeaderExtn   
)

◆ TEST() [36/40]

cricket::TEST ( RtpUtilsTest  ,
UpdateAbsSendTimeExtensionInTurnSendIndication   
)

◆ TEST() [37/40]

cricket::TEST ( RtpUtilsTest  ,
ApplyPacketOptionsWithDefaultValues   
)

◆ TEST() [38/40]

cricket::TEST ( RtpUtilsTest  ,
ApplyPacketOptionsWithAuthParams   
)

◆ TEST() [39/40]

cricket::TEST ( RtpUtilsTest  ,
UpdateAbsSendTimeExtensionInRtpPacket   
)

◆ TEST() [40/40]

cricket::TEST ( RtpUtilsTest  ,
ApplyPacketOptionsWithAuthParamsAndAbsSendTime   
)

◆ TEST_F() [1/507]

cricket::TEST_F ( ScreenshareLayerConfigTest  ,
UsesDefaultBitrateConfigForDefaultGroup   
)

◆ TEST_F() [2/507]

cricket::TEST_F ( ScreenshareLayerConfigTest  ,
UsesDefaultConfigForInvalidBitrates   
)

◆ TEST_F() [3/507]

cricket::TEST_F ( PayloadTypeMapperTest  ,
StaticPayloadTypes   
)

◆ TEST_F() [4/507]

cricket::TEST_F ( ScreenshareLayerConfigTest  ,
ParsesValidBitrateConfig   
)

◆ TEST_F() [5/507]

cricket::TEST_F ( TurnServerConnectionTest  ,
ComparisonOperators   
)

◆ TEST_F() [6/507]

cricket::TEST_F ( PayloadTypeMapperTest  ,
WebRTCPayloadTypes   
)

◆ TEST_F() [7/507]

cricket::TEST_F ( CurrentSpeakerMonitorTest  ,
NoActiveStreams   
)

◆ TEST_F() [8/507]

cricket::TEST_F ( ChannelManagerTest  ,
StartupShutdown   
)

◆ TEST_F() [9/507]

cricket::TEST_F ( CurrentSpeakerMonitorTest  ,
MultipleActiveStreams   
)

◆ TEST_F() [10/507]

cricket::TEST_F ( ChannelManagerTest  ,
StartupShutdownOnThread   
)

◆ TEST_F() [11/507]

cricket::TEST_F ( PayloadTypeMapperTest  ,
ValidDynamicPayloadTypes   
)

◆ TEST_F() [12/507]

cricket::TEST_F ( ChannelManagerTest  ,
CreateDestroyChannels   
)

◆ TEST_F() [13/507]

cricket::TEST_F ( CurrentSpeakerMonitorTest  ,
DISABLED_RapidSpeakerChange   
)

◆ TEST_F() [14/507]

cricket::TEST_F ( ChannelManagerTest  ,
CreateDestroyChannelsOnThread   
)

◆ TEST_F() [15/507]

cricket::TEST_F ( CurrentSpeakerMonitorTest  ,
MAYBE_SpeakerChange   
)

◆ TEST_F() [16/507]

cricket::TEST_F ( PayloadTypeMapperTest  ,
ToAudioCodec   
)

◆ TEST_F() [17/507]

cricket::TEST_F ( AsyncStunTCPSocketTest  ,
TestSingleStunPacket   
)

◆ TEST_F() [18/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptNothing   
)

◆ TEST_F() [19/507]

cricket::TEST_F ( AsyncStunTCPSocketTest  ,
TestMultipleStunPackets   
)

◆ TEST_F() [20/507]

cricket::TEST_F ( UdpTransportTest  ,
AddressGetters   
)

◆ TEST_F() [21/507]

cricket::TEST_F ( ChannelManagerTest  ,
SetVideoRtxEnabled   
)

◆ TEST_F() [22/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptZeroInterval   
)

◆ TEST_F() [23/507]

cricket::TEST_F ( AsyncStunTCPSocketTest  ,
TestTurnChannelDataWithZeroLength   
)

◆ TEST_F() [24/507]

cricket::TEST_F ( UdpTransportTest  ,
SettingIncompleteRemoteAddressFails   
)

◆ TEST_F() [25/507]

cricket::TEST_F ( CurrentSpeakerMonitorTest  ,
InterwordSilence   
)

◆ TEST_F() [26/507]

cricket::TEST_F ( UdpTransportTest  ,
SendRecvBasic   
)

◆ TEST_F() [27/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
AnnouncesVp9AccordingToBuildFlags   
)

◆ TEST_F() [28/507]

cricket::TEST_F ( AsyncStunTCPSocketTest  ,
TestTurnChannelData   
)

◆ TEST_F() [29/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptFramerateToHalf   
)

◆ TEST_F() [30/507]

cricket::TEST_F ( AsyncStunTCPSocketTest  ,
TestTurnChannelDataPadding   
)

◆ TEST_F() [31/507]

cricket::TEST_F ( UdpTransportTest  ,
StatusAndSignals   
)

◆ TEST_F() [32/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
DefaultRtxCodecHasAssociatedPayloadTypeSet   
)

◆ TEST_F() [33/507]

cricket::TEST_F ( AsyncStunTCPSocketTest  ,
TestStunInvalidLength   
)

◆ TEST_F() [34/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
SupportsTimestampOffsetHeaderExtension   
)

◆ TEST_F() [35/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSetIceConfig   
)

◆ TEST_F() [36/507]

cricket::TEST_F ( AsyncStunTCPSocketTest  ,
TestTurnChannelDataWithInvalidLength   
)

◆ TEST_F() [37/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
SupportsAbsoluteSenderTimeHeaderExtension   
)

◆ TEST_F() [38/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSetSslMaxProtocolVersion   
)

◆ TEST_F() [39/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
SupportsTransportSequenceNumberHeaderExtension   
)

◆ TEST_F() [40/507]

cricket::TEST_F ( AsyncStunTCPSocketTest  ,
TestTooSmallMessageBuffer   
)

◆ TEST_F() [41/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptFramerateToTwoThirds   
)

◆ TEST_F() [42/507]

cricket::TEST_F ( AsyncStunTCPSocketTest  ,
TestMaximumSizeTurnPacket   
)

◆ TEST_F() [43/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSetIceRole   
)

◆ TEST_F() [44/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
SupportsVideoRotationHeaderExtension   
)

◆ TEST_F() [45/507]

cricket::TEST_F ( SctpTransportTest  ,
SwitchTransportChannel   
)

◆ TEST_F() [46/507]

cricket::TEST_F ( AsyncStunTCPSocketTest  ,
TestMaximumSizeStunPacket   
)

◆ TEST_F() [47/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
CVOSetHeaderExtensionBeforeCapturer   
)

◆ TEST_F() [48/507]

cricket::TEST_F ( TransportControllerTest  ,
TestIceRoleConflict   
)

◆ TEST_F() [49/507]

cricket::TEST_F ( AsyncStunTCPSocketTest  ,
DISABLED_TestWithSmallSendBuffer   
)

◆ TEST_F() [50/507]

cricket::TEST_F ( TransportControllerTest  ,
TestGetSslRole   
)

◆ TEST_F() [51/507]

cricket::TEST_F ( SctpTransportTest  ,
DuplicateStartCallsIgnored   
)

◆ TEST_F() [52/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
CVOSetHeaderExtensionBeforeAddSendStream   
)

◆ TEST_F() [53/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptFramerateHighLimit   
)

◆ TEST_F() [54/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSetAndGetLocalCertificate   
)

◆ TEST_F() [55/507]

cricket::TEST_F ( SctpTransportTest  ,
CallingStartWithDifferentPortFails   
)

◆ TEST_F() [56/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptFramerateTimestampOffset   
)

◆ TEST_F() [57/507]

cricket::TEST_F ( SctpTransportTest  ,
NegativeOnePortTreatedAsDefault   
)

◆ TEST_F() [58/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
CVOSetHeaderExtensionAfterCapturer   
)

◆ TEST_F() [59/507]

cricket::TEST_F ( TransportControllerTest  ,
TestGetRemoteSSLCertificate   
)

◆ TEST_F() [60/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptFramerateTimestampJitter   
)

◆ TEST_F() [61/507]

cricket::TEST_F ( SctpTransportTest  ,
OpenStreamWithAlreadyOpenedStreamFails   
)

◆ TEST_F() [62/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSetLocalTransportDescription   
)

◆ TEST_F() [63/507]

cricket::TEST_F ( SctpTransportTest  ,
ResetStreamWithAlreadyResetStreamFails   
)

◆ TEST_F() [64/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
SetSendFailsBeforeSettingCodecs   
)

◆ TEST_F() [65/507]

cricket::TEST_F ( SctpTransportTest  ,
SignalReadyToSendDataAfterDtlsWritable   
)

◆ TEST_F() [66/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
GetStatsWithoutSendCodecsSetDoesNotCrash   
)

◆ TEST_F() [67/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSetRemoteTransportDescription   
)

◆ TEST_F() [68/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
UseExternalFactoryForVp8WhenSupported   
)

◆ TEST_F() [69/507]

cricket::TEST_F ( SctpTransportTest  ,
SignalReadyToSendDataAfterBlocked   
)

◆ TEST_F() [70/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptFramerateOntheFly   
)

◆ TEST_F() [71/507]

cricket::TEST_F ( TransportControllerTest  ,
TestAddRemoteCandidates   
)

◆ TEST_F() [72/507]

cricket::TEST_F ( TransportControllerTest  ,
TestReadyForRemoteCandidates   
)

◆ TEST_F() [73/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptFrameResolutionHighLimit   
)

◆ TEST_F() [74/507]

cricket::TEST_F ( SctpTransportTest  ,
SendData   
)

◆ TEST_F() [75/507]

cricket::TEST_F ( TransportControllerTest  ,
TestGetStats   
)

◆ TEST_F() [76/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
RtxCodecAddedForExternalCodec   
)

◆ TEST_F() [77/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptFrameResolutionIdentical   
)

◆ TEST_F() [78/507]

cricket::TEST_F ( TransportControllerTest  ,
TestCreateAndDestroyFakeDtlsTransport   
)

◆ TEST_F() [79/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptFrameResolutionQuarter   
)

◆ TEST_F() [80/507]

cricket::TEST_F ( SctpTransportTest  ,
SendDataBlocked   
)

◆ TEST_F() [81/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptFrameResolutionDrop   
)

◆ TEST_F() [82/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSignalConnectionStateFailed   
)

◆ TEST_F() [83/507]

cricket::TEST_F ( SctpTransportTest  ,
SendDataWithNonexistentStreamFails   
)

◆ TEST_F() [84/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptResolution   
)

◆ TEST_F() [85/507]

cricket::TEST_F ( SctpTransportTest  ,
ClosesRemoteStream   
)

◆ TEST_F() [86/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSignalConnectionStateConnected   
)

◆ TEST_F() [87/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
EnablesFullEncoderTimeForExternalEncoders   
)

◆ TEST_F() [88/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptResolutionOnTheFly   
)

◆ TEST_F() [89/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
DisablesFullEncoderTimeForNonExternalEncoders   
)

◆ TEST_F() [90/507]

cricket::TEST_F ( SctpTransportTest  ,
ClosesTwoRemoteStreams   
)

◆ TEST_F() [91/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
CanConstructDecoderForVp9EncoderFactory   
)

◆ TEST_F() [92/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
PropagatesInputFrameTimestamp   
)

◆ TEST_F() [93/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSignalConnectionStateComplete   
)

◆ TEST_F() [94/507]

cricket::TEST_F ( VideoAdapterTest  ,
DropAllFrames   
)

◆ TEST_F() [95/507]

cricket::TEST_F ( SctpTransportTest  ,
ClosesStreamsOnBothSides   
)

◆ TEST_F() [96/507]

cricket::TEST_F ( VideoAdapterTest  ,
TestOnOutputFormatRequest   
)

◆ TEST_F() [97/507]

cricket::TEST_F ( StunTest  ,
MessageTypes   
)

◆ TEST_F() [98/507]

cricket::TEST_F ( TransportControllerTest  ,
TestDestroyTransportAndStayConnected   
)

◆ TEST_F() [99/507]

cricket::TEST_F ( SctpTransportTest  ,
RefusesHighNumberedTransports   
)

◆ TEST_F() [100/507]

cricket::TEST_F ( SctpTransportTest  ,
DISABLED_ReusesAStream   
)

◆ TEST_F() [101/507]

cricket::TEST_F ( StunTest  ,
ReadMessageWithIPv4AddressAttribute   
)

◆ TEST_F() [102/507]

cricket::TEST_F ( StunTest  ,
ReadMessageWithIPv4XorAddressAttribute   
)

◆ TEST_F() [103/507]

cricket::TEST_F ( TransportControllerTest  ,
TestDestroyLastTransportWhileConnected   
)

◆ TEST_F() [104/507]

cricket::TEST_F ( StunTest  ,
ReadMessageWithIPv6AddressAttribute   
)

◆ TEST_F() [105/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSignalReceiving   
)

◆ TEST_F() [106/507]

cricket::TEST_F ( StunTest  ,
ReadMessageWithInvalidAddressAttribute   
)

◆ TEST_F() [107/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
UsesSimulcastAdapterForVp8Factories   
)

◆ TEST_F() [108/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSignalGatheringStateGathering   
)

◆ TEST_F() [109/507]

cricket::TEST_F ( StunTest  ,
ReadMessageWithIPv6XorAddressAttribute   
)

◆ TEST_F() [110/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSignalGatheringStateComplete   
)

◆ TEST_F() [111/507]

cricket::TEST_F ( StunTest  ,
ReadRfc5769RequestMessage   
)

◆ TEST_F() [112/507]

cricket::TEST_F ( VideoAdapterTest  ,
TestViewRequestPlusCameraSwitch   
)

◆ TEST_F() [113/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
ChannelWithExternalH264CanChangeToInternalVp8   
)

◆ TEST_F() [114/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSignalingWhenLastIncompleteTransportDestroyed   
)

◆ TEST_F() [115/507]

cricket::TEST_F ( StunTest  ,
ReadRfc5769ResponseMessage   
)

◆ TEST_F() [116/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
DontUseExternalEncoderFactoryForUnsupportedCodecs   
)

◆ TEST_F() [117/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnPortType   
)

◆ TEST_F() [118/507]

cricket::TEST_F ( TurnPortTest  ,
TestReconstructedServerUrl   
)

◆ TEST_F() [119/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSignalCandidatesGathered   
)

◆ TEST_F() [120/507]

cricket::TEST_F ( VideoAdapterTest  ,
TestVGAWidth   
)

◆ TEST_F() [121/507]

cricket::TEST_F ( StunTest  ,
ReadRfc5769ResponseMessageIPv6   
)

◆ TEST_F() [122/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory   
)

◆ TEST_F() [123/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSignalingOccursOnSignalingThread   
)

◆ TEST_F() [124/507]

cricket::TEST_F ( StunTest  ,
ReadRfc5769RequestMessageLongTermAuth   
)

◆ TEST_F() [125/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAllocate   
)

◆ TEST_F() [126/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestBasic   
)

◆ TEST_F() [127/507]

cricket::TEST_F ( VideoAdapterTest  ,
TestOnResolutionRequestInSmallSteps   
)

◆ TEST_F() [128/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnTcpAllocate   
)

◆ TEST_F() [129/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory   
)

◆ TEST_F() [130/507]

cricket::TEST_F ( TransportControllerTest  ,
IceRoleRedeterminedOnIceRestartByDefault   
)

◆ TEST_F() [131/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestIgnoreOnlyLoopbackNetworkByDefault   
)

◆ TEST_F() [132/507]

cricket::TEST_F ( StunTest  ,
ReadLegacyMessage   
)

◆ TEST_F() [133/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnTcpAllocationWhenProxyChangesAddressToLocalHost   
)

◆ TEST_F() [134/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnTcpOnAddressResolveFailure   
)

◆ TEST_F() [135/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestIgnoreNetworksAccordingToIgnoreMask   
)

◆ TEST_F() [136/507]

cricket::TEST_F ( StunTest  ,
SetIPv6XorAddressAttributeOwner   
)

◆ TEST_F() [137/507]

cricket::TEST_F ( TransportControllerTest  ,
IceRoleNotRedetermined   
)

◆ TEST_F() [138/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
SimulcastDisabledForH264   
)

◆ TEST_F() [139/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnUdpOnAddressResolveFailure   
)

◆ TEST_F() [140/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestGatherLowCostNetworkOnly   
)

◆ TEST_F() [141/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAllocateBadPassword   
)

◆ TEST_F() [142/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAllocateNonceResetAfterAllocateMismatch   
)

◆ TEST_F() [143/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSetRemoteIceLiteInOffer   
)

◆ TEST_F() [144/507]

cricket::TEST_F ( VideoAdapterTest  ,
TestOnResolutionRequestMaxZero   
)

◆ TEST_F() [145/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
Flexfec03SupportedAsInternalCodecBehindFieldTrial   
)

◆ TEST_F() [146/507]

cricket::TEST_F ( StunTest  ,
SetIPv4XorAddressAttributeOwner   
)

◆ TEST_F() [147/507]

cricket::TEST_F ( VideoAdapterTest  ,
TestOnResolutionRequestInLargeSteps   
)

◆ TEST_F() [148/507]

cricket::TEST_F ( TransportControllerTest  ,
TestSetRemoteIceLiteInAnswer   
)

◆ TEST_F() [149/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
ReportSupportedExternalCodecs   
)

◆ TEST_F() [150/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAllocateMismatch   
)

◆ TEST_F() [151/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestLoopbackNetworkInterface   
)

◆ TEST_F() [152/507]

cricket::TEST_F ( VideoAdapterTest  ,
TestOnOutputFormatRequestCapsMaxResolution   
)

◆ TEST_F() [153/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
ReportSupportedExternalCodecsWithAddedCodec   
)

◆ TEST_F() [154/507]

cricket::TEST_F ( TransportControllerTest  ,
NeedsIceRestart   
)

◆ TEST_F() [155/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestGetAllPortsWithMinimumStepDelay   
)

◆ TEST_F() [156/507]

cricket::TEST_F ( StunTest  ,
CreateIPv6AddressAttribute   
)

◆ TEST_F() [157/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
RegisterExternalDecodersIfSupported   
)

◆ TEST_F() [158/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestSameNetworkDownAndUpWhenSessionNotStopped   
)

◆ TEST_F() [159/507]

cricket::TEST_F ( StunTest  ,
CreateIPv4AddressAttribute   
)

◆ TEST_F() [160/507]

cricket::TEST_F ( VideoAdapterTest  ,
TestOnResolutionRequestReset   
)

◆ TEST_F() [161/507]

cricket::TEST_F ( TurnPortTest  ,
TestSharedSocketAllocateMismatch   
)

◆ TEST_F() [162/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
RegisterExternalH264DecoderIfSupported   
)

◆ TEST_F() [163/507]

cricket::TEST_F ( StunTest  ,
CreateAddressInArbitraryOrder   
)

◆ TEST_F() [164/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestSameNetworkDownAndUpWhenSessionStopped   
)

◆ TEST_F() [165/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnTcpAllocateMismatch   
)

◆ TEST_F() [166/507]

cricket::TEST_F ( VideoAdapterTest  ,
TestCroppingWithResolutionRequest   
)

◆ TEST_F() [167/507]

cricket::TEST_F ( StunTest  ,
WriteMessageWithIPv6AddressAttribute   
)

◆ TEST_F() [168/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
StreamParamsIdPassedToDecoderFactory   
)

◆ TEST_F() [169/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestGetAllPortsWithOneSecondStepDelay   
)

◆ TEST_F() [170/507]

cricket::TEST_F ( TurnPortTest  ,
TestRefreshRequestGetsErrorResponse   
)

◆ TEST_F() [171/507]

cricket::TEST_F ( StunTest  ,
WriteMessageWithIPv4AddressAttribute   
)

◆ TEST_F() [172/507]

cricket::TEST_F ( WebRtcVideoEngine2Test  ,
DISABLED_RecreatesEncoderOnContentTypeChange   
)

◆ TEST_F() [173/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestSetupVideoRtpPortsWithNormalSendBuffers   
)

◆ TEST_F() [174/507]

cricket::TEST_F ( TurnPortTest  ,
TestStopProcessingPacketsAfterClosed   
)

◆ TEST_F() [175/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestStopGetAllPorts   
)

◆ TEST_F() [176/507]

cricket::TEST_F ( StunTest  ,
WriteMessageWithIPv6XorAddressAttribute   
)

◆ TEST_F() [177/507]

cricket::TEST_F ( VideoAdapterTest  ,
TestCroppingOddResolution   
)

◆ TEST_F() [178/507]

cricket::TEST_F ( TurnPortTest  ,
TestCreateConnectionWhenSocketClosed   
)

◆ TEST_F() [179/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestGetAllPortsPortRange   
)

◆ TEST_F() [180/507]

cricket::TEST_F ( VideoAdapterTest  ,
TestAdaptToVerySmallResolution   
)

◆ TEST_F() [181/507]

cricket::TEST_F ( TurnPortTest  ,
TestSocketCloseWillDestroyConnection   
)

◆ TEST_F() [182/507]

cricket::TEST_F ( StunTest  ,
WriteMessageWithIPv4XoreAddressAttribute   
)

◆ TEST_F() [183/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestGetAllPortsNoAdapters   
)

◆ TEST_F() [184/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAlternateServerUDP   
)

◆ TEST_F() [185/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAlternateServerTCP   
)

◆ TEST_F() [186/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAlternateServerV4toV6UDP   
)

◆ TEST_F() [187/507]

cricket::TEST_F ( VideoAdapterTest  ,
AdaptFrameResolutionDropWithResolutionRequest   
)

◆ TEST_F() [188/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAlternateServerV4toV6TCP   
)

◆ TEST_F() [189/507]

cricket::TEST_F ( StunTest  ,
ReadByteStringAttribute   
)

◆ TEST_F() [190/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAlternateServerPingPongUDP   
)

◆ TEST_F() [191/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAlternateServerPingPongTCP   
)

◆ TEST_F() [192/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAlternateServerDetectRepetitionUDP   
)

◆ TEST_F() [193/507]

cricket::TEST_F ( WebRtcVideoChannel2BaseTest  ,
SendAndReceiveVp8Vga   
)

◆ TEST_F() [194/507]

cricket::TEST_F ( StunTest  ,
ReadPaddedByteStringAttribute   
)

◆ TEST_F() [195/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAlternateServerDetectRepetitionTCP   
)

◆ TEST_F() [196/507]

cricket::TEST_F ( WebRtcVideoChannel2BaseTest  ,
SendAndReceiveVp8Qvga   
)

◆ TEST_F() [197/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestDisableAdapterEnumerationWithoutNatRelayTransportOnly   
)

◆ TEST_F() [198/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAlternateServerLoopbackUdpIpv4   
)

◆ TEST_F() [199/507]

cricket::TEST_F ( WebRtcVideoChannel2BaseTest  ,
SendAndReceiveVp8SvcQqvga   
)

◆ TEST_F() [200/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAlternateServerLoopbackUdpIpv6   
)

◆ TEST_F() [201/507]

cricket::TEST_F ( WebRtcVideoChannel2BaseTest  ,
TwoStreamsSendAndReceive   
)

◆ TEST_F() [202/507]

cricket::TEST_F ( StunTest  ,
ReadErrorCodeAttribute   
)

◆ TEST_F() [203/507]

cricket::TEST_F ( VideoAdapterTest  ,
TestAdaptToMax   
)

◆ TEST_F() [204/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAlternateServerLoopbackTcpIpv4   
)

◆ TEST_F() [205/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestDisableAdapterEnumerationBehindNatMultipleInterfaces   
)

◆ TEST_F() [206/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnAlternateServerLoopbackTcpIpv6   
)

◆ TEST_F() [207/507]

cricket::TEST_F ( StunTest  ,
ReadMessageWithAUInt16ListAttribute   
)

◆ TEST_F() [208/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnConnection   
)

◆ TEST_F() [209/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnConnectionUsingSharedSocket   
)

◆ TEST_F() [210/507]

cricket::TEST_F ( StunTest  ,
ReadMessageWithAnUnknownAttribute   
)

◆ TEST_F() [211/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnTcpConnection   
)

◆ TEST_F() [212/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestDisableAdapterEnumerationBehindNatWithTcp   
)

◆ TEST_F() [213/507]

cricket::TEST_F ( TurnPortTest  ,
TestDestroyTurnConnection   
)

◆ TEST_F() [214/507]

cricket::TEST_F ( StunTest  ,
ReadMessageWithOriginAttribute   
)

◆ TEST_F() [215/507]

cricket::TEST_F ( TurnPortTest  ,
TestDestroyTurnConnectionUsingSharedSocket   
)

◆ TEST_F() [216/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestDisableAdapterEnumerationWithoutNatOrServers   
)

◆ TEST_F() [217/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnTlsTcpConnectionFails   
)

◆ TEST_F() [218/507]

cricket::TEST_F ( StunTest  ,
WriteMessageWithAnErrorCodeAttribute   
)

◆ TEST_F() [219/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestDisableAdapterEnumerationWithoutNatLocalhostCandidateDisabled   
)

◆ TEST_F() [220/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnConnectionUsingOTUNonce   
)

◆ TEST_F() [221/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestDisableAdapterEnumerationWithoutNatLocalhostCandidateDisabledWithDifferentDefaultRoute   
)

◆ TEST_F() [222/507]

cricket::TEST_F ( TurnPortTest  ,
TestRefreshCreatePermissionRequest   
)

◆ TEST_F() [223/507]

cricket::TEST_F ( StunTest  ,
WriteMessageWithAUInt16ListAttribute   
)

◆ TEST_F() [224/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
HandleUfragPwdChange   
)

◆ TEST_F() [225/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
HandleUfragPwdChangeSymmetricNat   
)

◆ TEST_F() [226/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestDisableAdapterEnumerationWithNatLocalhostCandidateDisabled   
)

◆ TEST_F() [227/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
GetStats   
)

◆ TEST_F() [228/507]

cricket::TEST_F ( StunTest  ,
WriteMessageWithOriginAttribute   
)

◆ TEST_F() [229/507]

cricket::TEST_F ( TurnPortTest  ,
TestChannelBindGetErrorResponse   
)

◆ TEST_F() [230/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestDisableUdpTurn   
)

◆ TEST_F() [231/507]

cricket::TEST_F ( StunTest  ,
FailToReadInvalidMessages   
)

◆ TEST_F() [232/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnSendDataTurnUdpToUdp   
)

◆ TEST_F() [233/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TestUMAIceRestartWhileDisconnected   
)

◆ TEST_F() [234/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestDisableAllPorts   
)

◆ TEST_F() [235/507]

cricket::TEST_F ( StunTest  ,
FailToReadRtcpPacket   
)

◆ TEST_F() [236/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnSendDataTurnTcpToUdp   
)

◆ TEST_F() [237/507]

cricket::TEST_F ( StunTest  ,
ValidateMessageIntegrity   
)

◆ TEST_F() [238/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestGetAllPortsNoUdpSockets   
)

◆ TEST_F() [239/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnLocalIPv6AddressServerIPv4   
)

◆ TEST_F() [240/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnLocalIPv6AddressServerIPv6ExtenalIPv4   
)

◆ TEST_F() [241/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestGetAllPortsNoUdpSocketsNoTcpListen   
)

◆ TEST_F() [242/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TestUMAIceRestartWhileConnected   
)

◆ TEST_F() [243/507]

cricket::TEST_F ( TurnPortTest  ,
TestCandidateAddressFamilyMatch   
)

◆ TEST_F() [244/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestGetAllPortsNoSockets   
)

◆ TEST_F() [245/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TestUMAIceRestartWhileConnecting   
)

◆ TEST_F() [246/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestGetAllPortsNoUdpAllowed   
)

◆ TEST_F() [247/507]

cricket::TEST_F ( TurnPortTest  ,
TestOriginHeader   
)

◆ TEST_F() [248/507]

cricket::TEST_F ( TurnPortTest  ,
TestConnectionFailedAndPrunedOnCreatePermissionFailure   
)

◆ TEST_F() [249/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TestIceRegatheringReasonContinualGatheringByNetworkChange   
)

◆ TEST_F() [250/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestCandidatePriorityOfMultipleInterfaces   
)

◆ TEST_F() [251/507]

cricket::TEST_F ( StunTest  ,
AddMessageIntegrity   
)

◆ TEST_F() [252/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnReleaseAllocation   
)

◆ TEST_F() [253/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestGetAllPortsRestarts   
)

◆ TEST_F() [254/507]

cricket::TEST_F ( TurnPortTest  ,
TestTurnTCPReleaseAllocation   
)

◆ TEST_F() [255/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetsSyncGroupFromSyncLabel   
)

◆ TEST_F() [256/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestSessionUsesOwnCandidateFilter   
)

◆ TEST_F() [257/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TestIceRegatheringReasonContinualGatheringByNetworkFailure   
)

◆ TEST_F() [258/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RecvStreamWithSimAndRtx   
)

◆ TEST_F() [259/507]

cricket::TEST_F ( StunTest  ,
ValidateFingerprint   
)

◆ TEST_F() [260/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestCandidateFilterWithRelayOnly   
)

◆ TEST_F() [261/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
PeerReflexiveCandidateBeforeSignaling   
)

◆ TEST_F() [262/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RecvStreamWithRtx   
)

◆ TEST_F() [263/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestCandidateFilterWithHostOnly   
)

◆ TEST_F() [264/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RecvStreamNoRtx   
)

◆ TEST_F() [265/507]

cricket::TEST_F ( StunTest  ,
AddFingerprint   
)

◆ TEST_F() [266/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestCandidateFilterWithReflexiveOnly   
)

◆ TEST_F() [267/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
NoHeaderExtesionsByDefault   
)

◆ TEST_F() [268/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SendRtpTimestampOffsetHeaderExtensions   
)

◆ TEST_F() [269/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RecvRtpTimestampOffsetHeaderExtensions   
)

◆ TEST_F() [270/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestCandidateFilterWithReflexiveOnlyAndNoNAT   
)

◆ TEST_F() [271/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SendAbsoluteSendTimeHeaderExtensions   
)

◆ TEST_F() [272/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
PeerReflexiveCandidateBeforeSignalingWithNAT   
)

◆ TEST_F() [273/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RecvAbsoluteSendTimeHeaderExtensions   
)

◆ TEST_F() [274/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
FiltersExtensionsPicksTransportSeqNum   
)

◆ TEST_F() [275/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestEnableSharedUfrag   
)

◆ TEST_F() [276/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
FiltersExtensionsPicksAbsSendTime   
)

◆ TEST_F() [277/507]

cricket::TEST_F ( StunTest  ,
ReadRelayMessage   
)

◆ TEST_F() [278/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SendTransportSequenceNumberHeaderExtensions   
)

◆ TEST_F() [279/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RecvTransportSequenceNumberHeaderExtensions   
)

◆ TEST_F() [280/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SendVideoRotationHeaderExtensions   
)

◆ TEST_F() [281/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RecvVideoRotationHeaderExtensions   
)

◆ TEST_F() [282/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestSharedSocketWithoutNat   
)

◆ TEST_F() [283/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
IdenticalSendExtensionsDoesntRecreateStream   
)

◆ TEST_F() [284/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
PeerReflexiveCandidateBeforeSignalingWithIceRestart   
)

◆ TEST_F() [285/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestSharedSocketWithNat   
)

◆ TEST_F() [286/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
IdenticalRecvExtensionsDoesntRecreateStream   
)

◆ TEST_F() [287/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestSharedSocketWithoutNatUsingTurn   
)

◆ TEST_F() [288/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
RemoteCandidatesWithoutUfragPwd   
)

◆ TEST_F() [289/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendRtpHeaderExtensionsExcludeUnsupportedExtensions   
)

◆ TEST_F() [290/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestUdpTurnPortPrunesTcpTurnPortWithTcpPortReadyFirst   
)

◆ TEST_F() [291/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestUdpTurnPortPrunesTcpTurnPortsWithUdpPortReadyFirst   
)

◆ TEST_F() [292/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
IncomingOnlyBlocked   
)

◆ TEST_F() [293/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetRecvRtpHeaderExtensionsExcludeUnsupportedExtensions   
)

◆ TEST_F() [294/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestIPv6TurnPortPrunesIPv4TurnPortWithIPv4PortReadyFirst   
)

◆ TEST_F() [295/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestIPv6TurnPortPrunesIPv4TurnPortWithIPv6PortReadyFirst   
)

◆ TEST_F() [296/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendRtpHeaderExtensionsRejectsIncorrectIds   
)

◆ TEST_F() [297/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
IncomingOnlyOpen   
)

◆ TEST_F() [298/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestEachInterfaceHasItsOwnTurnPortsNoDelay   
)

◆ TEST_F() [299/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetRecvRtpHeaderExtensionsRejectsIncorrectIds   
)

◆ TEST_F() [300/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestEachInterfaceHasItsOwnTurnPortsWithTcpIPv4ReadyFirst   
)

◆ TEST_F() [301/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TestTcpConnectionsFromActiveToPassive   
)

◆ TEST_F() [302/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendRtpHeaderExtensionsRejectsDuplicateIds   
)

◆ TEST_F() [303/507]

cricket::TEST_F ( BasicPortAllocatorTestWithRealClock  ,
TestSharedSocketWithServerAddressResolve   
)

◆ TEST_F() [304/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetRecvRtpHeaderExtensionsRejectsDuplicateIds   
)

◆ TEST_F() [305/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
AddRecvStreamOnlyUsesOneReceiveStream   
)

◆ TEST_F() [306/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RtcpIsCompoundByDefault   
)

◆ TEST_F() [307/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestSharedSocketWithNatUsingTurn   
)

◆ TEST_F() [308/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RembIsEnabledByDefault   
)

◆ TEST_F() [309/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
TransportCcIsEnabledByDefault   
)

◆ TEST_F() [310/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TestIceRoleConflict   
)

◆ TEST_F() [311/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RembCanBeEnabledAndDisabled   
)

◆ TEST_F() [312/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TestIceConfigWillPassDownToPort   
)

◆ TEST_F() [313/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestSharedSocketWithNatUsingTurnAsStun   
)

◆ TEST_F() [314/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
TransportCcCanBeEnabledAndDisabled   
)

◆ TEST_F() [315/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
NackIsEnabledByDefault   
)

◆ TEST_F() [316/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TestDefaultDscpValue   
)

◆ TEST_F() [317/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestSharedSocketWithNatUsingTurnTcpOnly   
)

◆ TEST_F() [318/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
NackCanBeEnabledAndDisabled   
)

◆ TEST_F() [319/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TestIPv6Connections   
)

◆ TEST_F() [320/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestNonSharedSocketWithNatUsingTurnAsStun   
)

◆ TEST_F() [321/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
ReconfiguresEncodersWhenNotSending   
)

◆ TEST_F() [322/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TestForceTurn   
)

◆ TEST_F() [323/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
UsesCorrectSettingsForScreencast   
)

◆ TEST_F() [324/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestSharedSocketWithNatUsingTurnAndStun   
)

◆ TEST_F() [325/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TestContinualGathering   
)

◆ TEST_F() [326/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestSharedSocketNoUdpAllowed   
)

◆ TEST_F() [327/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TestUsingPooledSessionBeforeDoneGathering   
)

◆ TEST_F() [328/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestNetworkPermissionBlocked   
)

◆ TEST_F() [329/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
ConferenceModeScreencastConfiguresTemporalLayer   
)

◆ TEST_F() [330/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestEnableIPv6Addresses   
)

◆ TEST_F() [331/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TestUsingPooledSessionAfterDoneGathering   
)

◆ TEST_F() [332/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestStopGettingPorts   
)

◆ TEST_F() [333/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SuspendBelowMinBitrateDisabledByDefault   
)

◆ TEST_F() [334/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetMediaConfigSuspendBelowMinBitrate   
)

◆ TEST_F() [335/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestClearGettingPorts   
)

◆ TEST_F() [336/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
Vp8DenoisingEnabledByDefault   
)

◆ TEST_F() [337/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
VerifyVp8SpecificSettings   
)

◆ TEST_F() [338/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TurnToTurnPresumedWritable   
)

◆ TEST_F() [339/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestTransportInformationUpdated   
)

◆ TEST_F() [340/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
TurnToPrflxPresumedWritable   
)

◆ TEST_F() [341/507]

cricket::TEST_F ( BasicPortAllocatorTest  ,
TestSetCandidateFilterAfterCandidatesGathered   
)

◆ TEST_F() [342/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetIdenticalOptionsDoesntReconfigureEncoder   
)

◆ TEST_F() [343/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
PresumedWritablePreferredOverUnreliable   
)

◆ TEST_F() [344/507]

cricket::TEST_F ( P2PTransportChannelTest  ,
SignalReadyToSendWithPresumedWritable   
)

◆ TEST_F() [345/507]

cricket::TEST_F ( Vp9SettingsTest  ,
VerifyVp9SpecificSettings   
)

◆ TEST_F() [346/507]

cricket::TEST_F ( P2PTransportChannelSameNatTest  ,
TestConesBehindSameCone   
)

◆ TEST_F() [347/507]

cricket::TEST_F ( Vp9SettingsTestWithNoFlag  ,
VerifySettings   
)

◆ TEST_F() [348/507]

cricket::TEST_F ( Vp9SettingsTestWithInvalidFlag  ,
VerifySettings   
)

◆ TEST_F() [349/507]

cricket::TEST_F ( Vp9SettingsTestWith2SL3TLFlag  ,
VerifySettings   
)

◆ TEST_F() [350/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestBasic   
)

◆ TEST_F() [351/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
AdaptsOnOveruse   
)

◆ TEST_F() [352/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
DoesNotAdaptOnOveruseWhenDisabled   
)

◆ TEST_F() [353/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
DoesNotAdaptOnOveruseWhenScreensharing   
)

◆ TEST_F() [354/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestFailoverControlledSide   
)

◆ TEST_F() [355/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
AdaptsOnOveruseAndChangeResolution   
)

◆ TEST_F() [356/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestFailoverControllingSide   
)

◆ TEST_F() [357/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
PreviousAdaptationDoesNotApplyToScreenshare   
)

◆ TEST_F() [358/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestFailoverWithManyConnections   
)

◆ TEST_F() [359/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestIceRenomination   
)

◆ TEST_F() [360/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
EstimatesNtpStartTimeCorrectly   
)

◆ TEST_F() [361/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestConnectionSwitchDampeningControlledSide   
)

◆ TEST_F() [362/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetDefaultSendCodecs   
)

◆ TEST_F() [363/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
FlexfecCodecWithoutSsrcNotExposedByDefault   
)

◆ TEST_F() [364/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
FlexfecCodecWithSsrcNotExposedByDefault   
)

◆ TEST_F() [365/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestConnectionSwitchDampeningControllingSide   
)

◆ TEST_F() [366/507]

cricket::TEST_F ( WebRtcVideoChannel2FlexfecTest  ,
DefaultFlexfecCodecHasTransportCcAndRembFeedbackParam   
)

◆ TEST_F() [367/507]

cricket::TEST_F ( WebRtcVideoChannel2FlexfecTest  ,
SetDefaultSendCodecsWithoutSsrc   
)

◆ TEST_F() [368/507]

cricket::TEST_F ( WebRtcVideoChannel2FlexfecTest  ,
SetDefaultSendCodecsWithSsrc   
)

◆ TEST_F() [369/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsWithoutFec   
)

◆ TEST_F() [370/507]

cricket::TEST_F ( WebRtcVideoChannel2FlexfecTest  ,
SetSendCodecsWithoutFec   
)

◆ TEST_F() [371/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestRemoteFailover   
)

◆ TEST_F() [372/507]

cricket::TEST_F ( WebRtcVideoChannel2FlexfecTest  ,
SetRecvCodecsWithFec   
)

◆ TEST_F() [373/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecRejectsRtxWithoutAssociatedPayloadType   
)

◆ TEST_F() [374/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestPreferWifiToWifiConnection   
)

◆ TEST_F() [375/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecRejectsRtxWithoutMatchingVideoCodec   
)

◆ TEST_F() [376/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsWithChangedRtxPayloadType   
)

◆ TEST_F() [377/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestPreferWifiOverCellularNetwork   
)

◆ TEST_F() [378/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestPingBackupConnectionRate   
)

◆ TEST_F() [379/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsWithoutFecDisablesFec   
)

◆ TEST_F() [380/507]

cricket::TEST_F ( WebRtcVideoChannel2FlexfecTest  ,
SetSendCodecsWithoutFecDisablesFec   
)

◆ TEST_F() [381/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestGetState   
)

◆ TEST_F() [382/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsChangesExistingStreams   
)

◆ TEST_F() [383/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestNetworkBecomesInactive   
)

◆ TEST_F() [384/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsWithBitrates   
)

◆ TEST_F() [385/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsWithHighMaxBitrate   
)

◆ TEST_F() [386/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsWithoutBitratesUsesCorrectDefaults   
)

◆ TEST_F() [387/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsCapsMinAndStartBitrate   
)

◆ TEST_F() [388/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsRejectsMaxLessThanMinBitrate   
)

◆ TEST_F() [389/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestContinualGatheringOnNewInterface   
)

◆ TEST_F() [390/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsWithBitratesAndMaxSendBandwidth   
)

◆ TEST_F() [391/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetMaxSendBandwidthShouldPreserveOtherBitrates   
)

◆ TEST_F() [392/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestSwitchLinksViaContinualGathering   
)

◆ TEST_F() [393/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetMaxSendBandwidthShouldBeRemovable   
)

◆ TEST_F() [394/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetMaxSendBandwidthAndAddSendStream   
)

◆ TEST_F() [395/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetMaxSendBitrateCanIncreaseSenderBitrate   
)

◆ TEST_F() [396/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate   
)

◆ TEST_F() [397/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsWithMaxQuantization   
)

◆ TEST_F() [398/507]

cricket::TEST_F ( P2PTransportChannelMultihomedTest  ,
TestRestoreBackupConnection   
)

◆ TEST_F() [399/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsRejectBadPayloadTypes   
)

◆ TEST_F() [400/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsAcceptAllValidPayloadTypes   
)

◆ TEST_F() [401/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsIdenticalFirstCodecDoesntRecreateStream   
)

◆ TEST_F() [402/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetRecvCodecsWithOnlyVp8   
)

◆ TEST_F() [403/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetRecvCodecsWithRtx   
)

◆ TEST_F() [404/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetRecvCodecsWithChangedRtxPayloadType   
)

◆ TEST_F() [405/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetRecvCodecsDifferentPayloadType   
)

◆ TEST_F() [406/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetRecvCodecsAcceptDefaultCodecs   
)

◆ TEST_F() [407/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetRecvCodecsRejectUnsupportedCodec   
)

◆ TEST_F() [408/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs   
)

◆ TEST_F() [409/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs   
)

◆ TEST_F() [410/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetRecvCodecsWithoutFecDisablesFec   
)

◆ TEST_F() [411/507]

cricket::TEST_F ( WebRtcVideoChannel2FlexfecTest  ,
SetRecvParamsWithoutFecDisablesFec   
)

◆ TEST_F() [412/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestTriggeredChecks   
)

◆ TEST_F() [413/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendParamsWithFecEnablesFec   
)

◆ TEST_F() [414/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestAllConnectionsPingedSufficiently   
)

◆ TEST_F() [415/507]

cricket::TEST_F ( WebRtcVideoChannel2FlexfecTest  ,
SetSendParamsWithFecEnablesFec   
)

◆ TEST_F() [416/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestStunPingIntervals   
)

◆ TEST_F() [417/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSendCodecsRejectDuplicateFecPayloads   
)

◆ TEST_F() [418/507]

cricket::TEST_F ( WebRtcVideoChannel2FlexfecTest  ,
SetSendCodecsRejectDuplicateFecPayloads   
)

◆ TEST_F() [419/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetRecvCodecsRejectDuplicateCodecPayloads   
)

◆ TEST_F() [420/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes   
)

◆ TEST_F() [421/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetRecvCodecsDifferentOrderDoesntRecreateStream   
)

◆ TEST_F() [422/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SendStreamNotSendingByDefault   
)

◆ TEST_F() [423/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
ReceiveStreamReceivingByDefault   
)

◆ TEST_F() [424/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
PingingStartedAsSoonAsPossible   
)

◆ TEST_F() [425/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetSend   
)

◆ TEST_F() [426/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
TestSetDscpOptions   
)

◆ TEST_F() [427/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestNoTriggeredChecksWhenWritable   
)

◆ TEST_F() [428/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
TestSetSendRtcpReducedSize   
)

◆ TEST_F() [429/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestFailedConnectionNotPingable   
)

◆ TEST_F() [430/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
TestSetRecvRtcpReducedSize   
)

◆ TEST_F() [431/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestSignalStateChanged   
)

◆ TEST_F() [432/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
OnReadyToSendSignalsNetworkState   
)

◆ TEST_F() [433/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestAddRemoteCandidateWithVariousUfrags   
)

◆ TEST_F() [434/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetStatsReportsSentCodecName   
)

◆ TEST_F() [435/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetStatsReportsEncoderImplementationName   
)

◆ TEST_F() [436/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetStatsReportsCpuOveruseMetrics   
)

◆ TEST_F() [437/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetStatsReportsFramesEncoded   
)

◆ TEST_F() [438/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
ConnectionResurrection   
)

◆ TEST_F() [439/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetStatsReportsQpSum   
)

◆ TEST_F() [440/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetStatsReportsUpperResolution   
)

◆ TEST_F() [441/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetStatsReportsPreferredBitrate   
)

◆ TEST_F() [442/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetStatsReportsCpuAdaptationStats   
)

◆ TEST_F() [443/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestReceivingStateChange   
)

◆ TEST_F() [444/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetStatsReportsAdaptationAndBandwidthStats   
)

◆ TEST_F() [445/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetStatsTranslatesBandwidthLimitedResolutionCorrectly   
)

◆ TEST_F() [446/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestSelectConnectionBeforeNomination   
)

◆ TEST_F() [447/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetStatsTranslatesSendRtcpPacketTypesCorrectly   
)

◆ TEST_F() [448/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetStatsTranslatesReceiveRtcpPacketTypesCorrectly   
)

◆ TEST_F() [449/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetStatsTranslatesDecodeStatsCorrectly   
)

◆ TEST_F() [450/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestSelectConnectionFromUnknownAddress   
)

◆ TEST_F() [451/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetStatsTranslatesReceivePacketStatsCorrectly   
)

◆ TEST_F() [452/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
TranslatesCallStatsCorrectly   
)

◆ TEST_F() [453/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
TranslatesSenderBitrateStatsCorrectly   
)

◆ TEST_F() [454/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
DefaultReceiveStreamReconfiguresToUseRtx   
)

◆ TEST_F() [455/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestSelectConnectionBasedOnMediaReceived   
)

◆ TEST_F() [456/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RejectsAddingStreamsWithMissingSsrcsForRtx   
)

◆ TEST_F() [457/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RejectsAddingStreamsWithOverlappingRtxSsrcs   
)

◆ TEST_F() [458/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestControlledAgentDataReceivingTakesHigherPrecedenceThanPriority   
)

◆ TEST_F() [459/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RejectsAddingStreamsWithOverlappingSimulcastSsrcs   
)

◆ TEST_F() [460/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
ReportsSsrcGroupsInStats   
)

◆ TEST_F() [461/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestControlledAgentNominationTakesHigherPrecedenceThanDataReceiving   
)

◆ TEST_F() [462/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
MapsReceivedPayloadTypeToCodecName   
)

◆ TEST_F() [463/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestControlledAgentSelectsConnectionWithHigherNomination   
)

◆ TEST_F() [464/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestControlledAgentIgnoresSmallerNomination   
)

◆ TEST_F() [465/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
Vp8PacketCreatesUnsignalledStream   
)

◆ TEST_F() [466/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
Vp9PacketCreatesUnsignalledStream   
)

◆ TEST_F() [467/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RtxPacketDoesntCreateUnsignalledStream   
)

◆ TEST_F() [468/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestControlledAgentWriteStateTakesHigherPrecedenceThanNomination   
)

◆ TEST_F() [469/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
UlpfecPacketDoesntCreateUnsignalledStream   
)

◆ TEST_F() [470/507]

cricket::TEST_F ( WebRtcVideoChannel2FlexfecTest  ,
FlexfecPacketDoesntCreateUnsignalledStream   
)

◆ TEST_F() [471/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
RedRtxPacketDoesntCreateUnsignalledStream   
)

◆ TEST_F() [472/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
ReceiveDifferentUnsignaledSsrc   
)

◆ TEST_F() [473/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestAddRemoteCandidateWithAddressReuse   
)

◆ TEST_F() [474/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestDontPruneWhenWeak   
)

◆ TEST_F() [475/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
CanSentMaxBitrateForExistingStream   
)

◆ TEST_F() [476/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestDontPruneHighPriorityConnections   
)

◆ TEST_F() [477/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
CannotSetMaxBitrateForNonexistentStream   
)

◆ TEST_F() [478/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
CannotSetRtpSendParametersWithIncorrectNumberOfEncodings   
)

◆ TEST_F() [479/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestGetState   
)

◆ TEST_F() [480/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
CannotSetSsrcInRtpSendParameters   
)

◆ TEST_F() [481/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetRtpSendParametersEncodingsActive   
)

◆ TEST_F() [482/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestConnectionPrunedAgain   
)

◆ TEST_F() [483/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
InactiveStreamDoesntStartSendingWhenReconfigured   
)

◆ TEST_F() [484/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestDeleteConnectionsIfAllWriteTimedout   
)

◆ TEST_F() [485/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetRtpSendParametersCodecs   
)

◆ TEST_F() [486/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetRtpSendParametersSsrc   
)

◆ TEST_F() [487/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestStopPortAllocatorSessions   
)

◆ TEST_F() [488/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetAndGetRtpSendParameters   
)

◆ TEST_F() [489/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetRtpReceiveParametersCodecs   
)

◆ TEST_F() [490/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestIceRoleUpdatedOnRemovedPort   
)

◆ TEST_F() [491/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
DISABLED_GetRtpReceiveFmtpSprop   
)

◆ TEST_F() [492/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestIceRoleUpdatedOnPortAfterIceRestart   
)

◆ TEST_F() [493/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
GetRtpReceiveParametersSsrc   
)

◆ TEST_F() [494/507]

cricket::TEST_F ( P2PTransportChannelPingTest  ,
TestPortDestroyedAfterTimeoutAndPruned   
)

◆ TEST_F() [495/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
SetAndGetRtpReceiveParameters   
)

◆ TEST_F() [496/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
ConfiguresLocalSsrc   
)

◆ TEST_F() [497/507]

cricket::TEST_F ( WebRtcVideoChannel2Test  ,
ConfiguresLocalSsrcOnExistingReceivers   
)

◆ TEST_F() [498/507]

cricket::TEST_F ( P2PTransportChannelMostLikelyToWorkFirstTest  ,
TestRelayRelayFirstWhenNothingPingedYet   
)

◆ TEST_F() [499/507]

cricket::TEST_F ( P2PTransportChannelMostLikelyToWorkFirstTest  ,
TestRelayRelayFirstWhenEverythingPinged   
)

◆ TEST_F() [500/507]

cricket::TEST_F ( P2PTransportChannelMostLikelyToWorkFirstTest  ,
TestNoStarvationOnNonRelayConnection   
)

◆ TEST_F() [501/507]

cricket::TEST_F ( P2PTransportChannelMostLikelyToWorkFirstTest  ,
TestTcpTurn   
)

◆ TEST_F() [502/507]

cricket::TEST_F ( WebRtcVideoChannel2SimulcastTest  ,
SetSendCodecsWith2SimulcastStreams   
)

◆ TEST_F() [503/507]

cricket::TEST_F ( WebRtcVideoChannel2SimulcastTest  ,
SetSendCodecsWith3SimulcastStreams   
)

◆ TEST_F() [504/507]

cricket::TEST_F ( WebRtcVideoChannel2SimulcastTest  ,
SetSendCodecsWithOddSizeInSimulcast   
)

◆ TEST_F() [505/507]

cricket::TEST_F ( WebRtcVideoChannel2SimulcastTest  ,
SetSendCodecsForScreenshare   
)

◆ TEST_F() [506/507]

cricket::TEST_F ( WebRtcVideoChannel2SimulcastTest  ,
SetSendCodecsForConferenceModeScreenshare   
)

◆ TEST_F() [507/507]

cricket::TEST_F ( WebRtcVideoChannel2SimulcastTest  ,
SetSendCodecsForSimulcastScreenshare   
)

◆ UnwrapTurnPacket()

bool cricket::UnwrapTurnPacket ( const uint8_t *  packet,
size_t  packet_size,
size_t *  content_position,
size_t *  content_size 
)

◆ UpdateRtpAbsSendTimeExtension()

bool cricket::UpdateRtpAbsSendTimeExtension ( uint8_t *  rtp,
size_t  length,
int  extension_id,
uint64_t  time_us 
)

◆ UseSimulcastScreenshare()

bool cricket::UseSimulcastScreenshare ( )

◆ ValidateRtpExtensions()

bool cricket::ValidateRtpExtensions ( const std::vector< webrtc::RtpExtension > &  extensions)

◆ ValidateRtpHeader()

bool cricket::ValidateRtpHeader ( const uint8_t *  rtp,
size_t  length,
size_t *  header_length 
)

◆ VerifyCandidate()

bool cricket::VerifyCandidate ( const Candidate &  candidate,
std::string *  error 
)

◆ VerifyCandidates()

bool cricket::VerifyCandidates ( const Candidates &  candidates,
std::string *  error 
)

◆ WEBRTC_BASE_TEST() [1/16]

cricket::WEBRTC_BASE_TEST ( SetSend  )

◆ WEBRTC_BASE_TEST() [2/16]

cricket::WEBRTC_BASE_TEST ( SetSendWithoutCodecs  )

◆ WEBRTC_BASE_TEST() [3/16]

cricket::WEBRTC_BASE_TEST ( SetSendSetsTransportBufferSizes  )

◆ WEBRTC_BASE_TEST() [4/16]

cricket::WEBRTC_BASE_TEST ( GetStats  )

◆ WEBRTC_BASE_TEST() [5/16]

cricket::WEBRTC_BASE_TEST ( GetStatsMultipleRecvStreams  )

◆ WEBRTC_BASE_TEST() [6/16]

cricket::WEBRTC_BASE_TEST ( GetStatsMultipleSendStreams  )

◆ WEBRTC_BASE_TEST() [7/16]

cricket::WEBRTC_BASE_TEST ( SetSendBandwidth  )

◆ WEBRTC_BASE_TEST() [8/16]

cricket::WEBRTC_BASE_TEST ( SetSendSsrc  )

◆ WEBRTC_BASE_TEST() [9/16]

cricket::WEBRTC_BASE_TEST ( SetSendSsrcAfterSetCodecs  )

◆ WEBRTC_BASE_TEST() [10/16]

cricket::WEBRTC_BASE_TEST ( SetSink  )

◆ WEBRTC_BASE_TEST() [11/16]

cricket::WEBRTC_BASE_TEST ( AddRemoveSendStreams  )

◆ WEBRTC_BASE_TEST() [12/16]

cricket::WEBRTC_BASE_TEST ( SimulateConference  )

◆ WEBRTC_BASE_TEST() [13/16]

cricket::WEBRTC_BASE_TEST ( RemoveCapturerWithoutAdd  )

◆ WEBRTC_BASE_TEST() [14/16]

cricket::WEBRTC_BASE_TEST ( AddRemoveCapturerMultipleSources  )

◆ WEBRTC_BASE_TEST() [15/16]

cricket::WEBRTC_BASE_TEST ( RejectEmptyStreamParams  )

◆ WEBRTC_BASE_TEST() [16/16]

cricket::WEBRTC_BASE_TEST ( MultipleSendStreams  )

◆ WEBRTC_DISABLED_BASE_TEST()

cricket::WEBRTC_DISABLED_BASE_TEST ( AddRemoveCapturer  )

Variable Documentation

◆ CLOSED_TIMEOUT

const long cricket::CLOSED_TIMEOUT = 60 * 1000

◆ CN_AUDIO

const char cricket::CN_AUDIO = "audio"

◆ CN_DATA

const char cricket::CN_DATA = "data"

◆ CN_OTHER

const char cricket::CN_OTHER = "main"

◆ CN_VIDEO

const char cricket::CN_VIDEO = "video"

◆ CONNECTIONROLE_ACTIVE_STR

const char cricket::CONNECTIONROLE_ACTIVE_STR = "active"

◆ CONNECTIONROLE_ACTPASS_STR

const char cricket::CONNECTIONROLE_ACTPASS_STR = "actpass"

◆ CONNECTIONROLE_HOLDCONN_STR

const char cricket::CONNECTIONROLE_HOLDCONN_STR = "holdconn"

◆ CONNECTIONROLE_PASSIVE_STR

const char cricket::CONNECTIONROLE_PASSIVE_STR = "passive"

◆ CTL_CONNECT

const uint8_t cricket::CTL_CONNECT = 0

◆ DEF_ACK_DELAY

const uint32_t cricket::DEF_ACK_DELAY = 100

◆ DEF_RTO

const uint32_t cricket::DEF_RTO = 3000

◆ DEFAULT_RCV_BUF_SIZE

const uint32_t cricket::DEFAULT_RCV_BUF_SIZE = 60 * 1024

◆ DEFAULT_SND_BUF_SIZE

const uint32_t cricket::DEFAULT_SND_BUF_SIZE = 90 * 1024

◆ DEFAULT_TIMEOUT

const long cricket::DEFAULT_TIMEOUT = 4000

◆ DISABLE_ALL_PHASES

const uint32_t cricket::DISABLE_ALL_PHASES
Initial value:
=
PORTALLOCATOR_DISABLE_UDP | PORTALLOCATOR_DISABLE_TCP |
PORTALLOCATOR_DISABLE_STUN | PORTALLOCATOR_DISABLE_RELAY
cricket::PORTALLOCATOR_DISABLE_UDP
Definition: portallocator.h:40
cricket::PORTALLOCATOR_DISABLE_STUN
Definition: portallocator.h:41
cricket::PORTALLOCATOR_DISABLE_RELAY
Definition: portallocator.h:42
cricket::PORTALLOCATOR_DISABLE_TCP
Definition: portallocator.h:45

◆ DISCARD_PORT

const int cricket::DISCARD_PORT = 9

◆ EMPTY_TRANSACTION_ID

const char cricket::EMPTY_TRANSACTION_ID[] = "0000000000000000"

◆ FLAG_CTL

const uint8_t cricket::FLAG_CTL = 0x02

◆ FLAG_RST

const uint8_t cricket::FLAG_RST = 0x04

◆ GROUP_TYPE_BUNDLE

const char cricket::GROUP_TYPE_BUNDLE = "BUNDLE"

◆ HEADER_SIZE

const uint32_t cricket::HEADER_SIZE = 24

◆ ICE_CANDIDATE_COMPONENT_DEFAULT

const int cricket::ICE_CANDIDATE_COMPONENT_DEFAULT = 1

◆ ICE_CANDIDATE_COMPONENT_RTCP

const int cricket::ICE_CANDIDATE_COMPONENT_RTCP = 2

◆ ICE_CANDIDATE_COMPONENT_RTP

const int cricket::ICE_CANDIDATE_COMPONENT_RTP = 1

◆ ICE_PWD_LENGTH

const int cricket::ICE_PWD_LENGTH = 24

◆ ICE_PWD_MAX_LENGTH

const size_t cricket::ICE_PWD_MAX_LENGTH = 256

◆ ICE_PWD_MIN_LENGTH

const size_t cricket::ICE_PWD_MIN_LENGTH = 22

◆ ICE_RENOMINATION_STR

constexpr auto cricket::ICE_RENOMINATION_STR = "renomination"

◆ ICE_UFRAG_LENGTH

const int cricket::ICE_UFRAG_LENGTH = 4

◆ ICE_UFRAG_MAX_LENGTH

const size_t cricket::ICE_UFRAG_MAX_LENGTH = 255

◆ ICE_UFRAG_MIN_LENGTH

const size_t cricket::ICE_UFRAG_MIN_LENGTH = 4

◆ IP_HEADER_SIZE

const uint32_t cricket::IP_HEADER_SIZE = 20

◆ JINGLE_HEADER_SIZE

const uint32_t cricket::JINGLE_HEADER_SIZE = 64

◆ kAllRequests

const int cricket::kAllRequests = 0

◆ kAutoBandwidth

const int cricket::kAutoBandwidth = -1

◆ kBufferedModeDisabled

const int cricket::kBufferedModeDisabled = 0

◆ kCnCodecName

const char cricket::kCnCodecName = "cn"

◆ kCodecParamAssociatedPayloadType

const char cricket::kCodecParamAssociatedPayloadType = "apt"

◆ kCodecParamMaxAverageBitrate

const char cricket::kCodecParamMaxAverageBitrate = "maxaveragebitrate"

◆ kCodecParamMaxBitrate

const char cricket::kCodecParamMaxBitrate = "x-google-max-bitrate"

◆ kCodecParamMaxPlaybackRate

const char cricket::kCodecParamMaxPlaybackRate = "maxplaybackrate"

◆ kCodecParamMaxPTime

const char cricket::kCodecParamMaxPTime = "maxptime"

◆ kCodecParamMaxQuantization

const char cricket::kCodecParamMaxQuantization = "x-google-max-quantization"

◆ kCodecParamMinBitrate

const char cricket::kCodecParamMinBitrate = "x-google-min-bitrate"

◆ kCodecParamMinPTime

const char cricket::kCodecParamMinPTime = "minptime"

◆ kCodecParamPort

const char cricket::kCodecParamPort = "x-google-port"

◆ kCodecParamPTime

const char cricket::kCodecParamPTime = "ptime"

◆ kCodecParamSctpProtocol

const char cricket::kCodecParamSctpProtocol = "protocol"

◆ kCodecParamSctpStreams

const char cricket::kCodecParamSctpStreams = "streams"

◆ kCodecParamSPropStereo

const char cricket::kCodecParamSPropStereo = "sprop-stereo"

◆ kCodecParamStartBitrate

const char cricket::kCodecParamStartBitrate = "x-google-start-bitrate"

◆ kCodecParamStereo

const char cricket::kCodecParamStereo = "stereo"

◆ kCodecParamUseDtx

const char cricket::kCodecParamUseDtx = "usedtx"

◆ kCodecParamUseInbandFec

const char cricket::kCodecParamUseInbandFec = "useinbandfec"

◆ kComfortNoiseCodecName

const char cricket::kComfortNoiseCodecName = "CN"

◆ kDataCodecClockrate

const int cricket::kDataCodecClockrate = 90000

◆ kDataMaxBandwidth

const int cricket::kDataMaxBandwidth = 30720

◆ kDefaultPortAllocatorFlags

const uint32_t cricket::kDefaultPortAllocatorFlags = 0

◆ kDefaultRtcpCname

const char cricket::kDefaultRtcpCname = "DefaultRtcpCname"

◆ kDefaultScreenshareSimulcastStreams

const int cricket::kDefaultScreenshareSimulcastStreams = 2

◆ kDefaultStepDelay

const uint32_t cricket::kDefaultStepDelay = 1000

◆ kDefaultVideoMaxFramerate

const int cricket::kDefaultVideoMaxFramerate = 60

◆ kDtmfCodecName

const char cricket::kDtmfCodecName = "telephone-event"

◆ kDummyVideoSsrc

const uint32_t cricket::kDummyVideoSsrc = 0xFFFFFFFF

◆ KEEPALIVE_DELAY

const int cricket::KEEPALIVE_DELAY = 10 * 1000

◆ kFecFrSsrcGroupSemantics

const char cricket::kFecFrSsrcGroupSemantics = "FEC-FR"

◆ kFecSsrcGroupSemantics

const char cricket::kFecSsrcGroupSemantics = "FEC"

◆ kFidSsrcGroupSemantics

const char cricket::kFidSsrcGroupSemantics = "FID"

◆ kFlexfecCodecName

const char cricket::kFlexfecCodecName = "flexfec-03"

◆ kFlexfecFmtpRepairWindow

const char cricket::kFlexfecFmtpRepairWindow = "repair-window"

◆ kG722CodecName

const char cricket::kG722CodecName = "g722"

◆ kGoogleRtpDataCodecName

const char cricket::kGoogleRtpDataCodecName = "google-data"

◆ kGoogleRtpDataCodecPlType

const int cricket::kGoogleRtpDataCodecPlType = 109

◆ kGoogleSctpDataCodecName

const char cricket::kGoogleSctpDataCodecName = "google-sctp-data"

◆ kGoogleSctpDataCodecPlType

const int cricket::kGoogleSctpDataCodecPlType = 108

◆ kH264CodecName

const char cricket::kH264CodecName = "H264"

◆ kH264FmtpLevelAsymmetryAllowed

const char cricket::kH264FmtpLevelAsymmetryAllowed = "level-asymmetry-allowed"

◆ kH264FmtpPacketizationMode

const char cricket::kH264FmtpPacketizationMode = "packetization-mode"

◆ kH264FmtpProfileLevelId

const char cricket::kH264FmtpProfileLevelId = "profile-level-id"

◆ kH264FmtpSpropParameterSets

const char cricket::kH264FmtpSpropParameterSets = "sprop-parameter-sets"

◆ kH264ProfileLevelConstrainedBaseline

const char cricket::kH264ProfileLevelConstrainedBaseline = "42e01f"

◆ kHighSystemCpuThreshold

const float cricket::kHighSystemCpuThreshold = 0.85f

◆ kIlbcCodecName

const char cricket::kIlbcCodecName = "ilbc"

◆ kIPv6TestAddress1

const in6_addr cricket::kIPv6TestAddress1
Initial value:
= { { { 0x24, 0x01, 0xfa, 0x00,
0x00, 0x04, 0x10, 0x00,
0xbe, 0x30, 0x5b, 0xff,
0xfe, 0xe5, 0x00, 0xc3 } } }

◆ kIPv6TestAddress2

const in6_addr cricket::kIPv6TestAddress2
Initial value:
= { { { 0x24, 0x01, 0xfa, 0x00,
0x00, 0x04, 0x10, 0x12,
0x06, 0x0c, 0xce, 0xff,
0xfe, 0x1f, 0x61, 0xa4 } } }

◆ kIsacCodecName

const char cricket::kIsacCodecName = "isac"

◆ kL16CodecName

const char cricket::kL16CodecName = "l16"

◆ kLowSystemCpuThreshold

const float cricket::kLowSystemCpuThreshold = 0.65f

◆ kMaxRtpPacketLen

const size_t cricket::kMaxRtpPacketLen = 2048

◆ kMaxSctpSid

constexpr uint16_t cricket::kMaxSctpSid = kMaxSctpStreams - 1

◆ kMaxSctpStreams

constexpr uint16_t cricket::kMaxSctpStreams = 1024

◆ kMediaProtocolAvpf

const char cricket::kMediaProtocolAvpf = "RTP/AVPF"

◆ kMediaProtocolDtlsSavpf

const char cricket::kMediaProtocolDtlsSavpf = "UDP/TLS/RTP/SAVPF"

◆ kMediaProtocolDtlsSctp

const char cricket::kMediaProtocolDtlsSctp = "DTLS/SCTP"

◆ kMediaProtocolRtpPrefix

const char cricket::kMediaProtocolRtpPrefix = "RTP/"

◆ kMediaProtocolSavpf

const char cricket::kMediaProtocolSavpf = "RTP/SAVPF"

◆ kMediaProtocolSctp

const char cricket::kMediaProtocolSctp = "SCTP"

◆ kMediaProtocolTcpDtlsSctp

const char cricket::kMediaProtocolTcpDtlsSctp = "TCP/DTLS/SCTP"

◆ kMediaProtocolUdpDtlsSctp

const char cricket::kMediaProtocolUdpDtlsSctp = "UDP/DTLS/SCTP"

◆ kMinimumStepDelay

const uint32_t cricket::kMinimumStepDelay = 50

◆ kMinRtcpPacketLen

const size_t cricket::kMinRtcpPacketLen = 4

◆ kMinRtpPacketLen

static const size_t cricket::kMinRtpPacketLen = 12

◆ kMinSctpSid

constexpr uint16_t cricket::kMinSctpSid = 0

◆ kMinVideoBitrateKbps

const int cricket::kMinVideoBitrateKbps = 30

◆ kOpusCodecName

const char cricket::kOpusCodecName = "opus"

◆ kOpusDefaultMaxPlaybackRate

const int cricket::kOpusDefaultMaxPlaybackRate = 48000

◆ kOpusDefaultMaxPTime

const int cricket::kOpusDefaultMaxPTime = 120

◆ kOpusDefaultMinPTime

const int cricket::kOpusDefaultMinPTime = 3

◆ kOpusDefaultPTime

const int cricket::kOpusDefaultPTime = 20

◆ kOpusDefaultSPropStereo

const int cricket::kOpusDefaultSPropStereo = 0

◆ kOpusDefaultStereo

const int cricket::kOpusDefaultStereo = 0

◆ kOpusDefaultUseDtx

const int cricket::kOpusDefaultUseDtx = 0

◆ kOpusDefaultUseInbandFec

const int cricket::kOpusDefaultUseInbandFec = 0

◆ kParamValueEmpty

const char cricket::kParamValueEmpty = ""

◆ kParamValueTrue

const char cricket::kParamValueTrue = "1"

◆ kPcmaCodecName

const char cricket::kPcmaCodecName = "pcma"

◆ kPcmuCodecName

const char cricket::kPcmuCodecName = "pcmu"

◆ kPreferredMaxPTime

const int cricket::kPreferredMaxPTime = 120

◆ kPreferredMinPTime

const int cricket::kPreferredMinPTime = 10

◆ kPreferredSPropStereo

const int cricket::kPreferredSPropStereo = 0

◆ kPreferredStereo

const int cricket::kPreferredStereo = 0

◆ kPreferredUseInbandFec

const int cricket::kPreferredUseInbandFec = 0

◆ kProcessCpuThreshold

const float cricket::kProcessCpuThreshold = 0.10f

◆ kRedCodecName

const char cricket::kRedCodecName = "red"

◆ kRtcpFbCcmParamFir

const char cricket::kRtcpFbCcmParamFir = "fir"

◆ kRtcpFbNackParamPli

const char cricket::kRtcpFbNackParamPli = "pli"

◆ kRtcpFbParamCcm

const char cricket::kRtcpFbParamCcm = "ccm"

◆ kRtcpFbParamNack

const char cricket::kRtcpFbParamNack = "nack"

◆ kRtcpFbParamRemb

const char cricket::kRtcpFbParamRemb = "goog-remb"

◆ kRtcpFbParamTransportCc

const char cricket::kRtcpFbParamTransportCc = "transport-cc"

◆ kRtxCodecName

const char cricket::kRtxCodecName = "rtx"

◆ kScreencastDefaultFps

const int cricket::kScreencastDefaultFps = 5

◆ kSctpDefaultPort

const int cricket::kSctpDefaultPort = 5000

◆ kSimSsrcGroupSemantics

const char cricket::kSimSsrcGroupSemantics = "SIM"

◆ kSimulcastFormats

const SimulcastFormat cricket::kSimulcastFormats[]
Initial value:
= {
{1920, 1080, 3, 5000, 4000, 800},
{1280, 720, 3, 2500, 2500, 600},
{960, 540, 3, 900, 900, 450},
{640, 360, 2, 700, 500, 150},
{480, 270, 2, 450, 350, 150},
{320, 180, 1, 200, 150, 30},
{0, 0, 1, 200, 150, 30}
}

◆ kStunAttributeHeaderSize

const size_t cricket::kStunAttributeHeaderSize = 4

◆ kStunHeaderSize

const size_t cricket::kStunHeaderSize = 20

◆ kStunLegacyTransactionIdLength

const size_t cricket::kStunLegacyTransactionIdLength = 16

◆ kStunMagicCookie

const uint32_t cricket::kStunMagicCookie = 0x2112A442

◆ kStunMagicCookieLength

const size_t cricket::kStunMagicCookieLength = sizeof(kStunMagicCookie)

◆ kStunMessageIntegritySize

const size_t cricket::kStunMessageIntegritySize = 20

◆ kStunTransactionIdLength

const size_t cricket::kStunTransactionIdLength = 12

◆ kStunTransactionIdOffset

const size_t cricket::kStunTransactionIdOffset = 8

◆ kStunTypeMask

const uint32_t cricket::kStunTypeMask = 0x0110

◆ kTestErrorClass

const int cricket::kTestErrorClass = 4

◆ kTestErrorCode

const int cricket::kTestErrorCode = 401

◆ kTestErrorNumber

const int cricket::kTestErrorNumber = 1

◆ kTestErrorReason

const char cricket::kTestErrorReason[] = "Unauthorized"

◆ kTestMessagePort1

const int cricket::kTestMessagePort1 = 59977

◆ kTestMessagePort2

const int cricket::kTestMessagePort2 = 47233

◆ kTestMessagePort3

const int cricket::kTestMessagePort3 = 56743

◆ kTestMessagePort4

const int cricket::kTestMessagePort4 = 40444

◆ kTestOrigin

const char cricket::kTestOrigin[] = "http://example.com"

◆ kTestTransactionId1

const unsigned char cricket::kTestTransactionId1[]
Initial value:
= { 0x029, 0x01f, 0x0cd, 0x07c,
0x0ba, 0x058, 0x0ab, 0x0d7,
0x0f2, 0x041, 0x001, 0x000 }

◆ kTestTransactionId2

const unsigned char cricket::kTestTransactionId2[]
Initial value:
= { 0x0e3, 0x0a9, 0x046, 0x0e1,
0x07c, 0x000, 0x0c2, 0x062,
0x054, 0x008, 0x001, 0x000 }

◆ kTestUserName1

const char cricket::kTestUserName1[] = "abcdefgh"

◆ kTestUserName2

const char cricket::kTestUserName2[] = "abc"

◆ kTimeoutMs

constexpr int cricket::kTimeoutMs = 10000

◆ kUlpfecCodecName

const char cricket::kUlpfecCodecName = "ulpfec"

◆ kVideoCodecClockrate

const int cricket::kVideoCodecClockrate = 90000

◆ kVideoMtu

const int cricket::kVideoMtu = 1200

◆ kVideoRtpBufferSize

const int cricket::kVideoRtpBufferSize = 65536

◆ kVp8CodecName

const char cricket::kVp8CodecName = "VP8"

◆ kVp9CodecName

const char cricket::kVp9CodecName = "VP9"

◆ LOCAL_PORT_TYPE

const char cricket::LOCAL_PORT_TYPE = "local"

◆ MAX_LIFETIME

const int cricket::MAX_LIFETIME = 15 * 60 * 1000

◆ MAX_PACKET

const uint32_t cricket::MAX_PACKET = 65535

◆ MAX_RTO

const uint32_t cricket::MAX_RTO = 60000

◆ MIN_PACKET

const uint32_t cricket::MIN_PACKET = 296

◆ MIN_RTO

const uint32_t cricket::MIN_RTO
Initial value:
=
250

◆ MSG_LIFETIME_TIMER

const uint32_t cricket::MSG_LIFETIME_TIMER = 1

◆ MSG_STUN_SEND

const uint32_t cricket::MSG_STUN_SEND = 1

◆ NS_JINGLE_DRAFT_SCTP

const char cricket::NS_JINGLE_DRAFT_SCTP = "google:jingle:sctp"

◆ NS_JINGLE_RTP

const char cricket::NS_JINGLE_RTP = "urn:xmpp:jingle:apps:rtp:1"

◆ PACKET_MAXIMUMS

const uint16_t cricket::PACKET_MAXIMUMS[]
Initial value:
= {
65535,
32000,
17914,
8166,
4352,
2002,
1492,
1006,
508,
296,
0,
}

◆ PACKET_OVERHEAD

const uint32_t cricket::PACKET_OVERHEAD
Initial value:
=
HEADER_SIZE + UDP_HEADER_SIZE + IP_HEADER_SIZE + JINGLE_HEADER_SIZE
cricket::JINGLE_HEADER_SIZE
const uint32_t JINGLE_HEADER_SIZE
Definition: pseudotcp.cc:72
cricket::IP_HEADER_SIZE
const uint32_t IP_HEADER_SIZE
Definition: pseudotcp.cc:69
cricket::HEADER_SIZE
const uint32_t HEADER_SIZE
Definition: pseudotcp.cc:106
cricket::UDP_HEADER_SIZE
const uint32_t UDP_HEADER_SIZE
Definition: pseudotcp.cc:70

◆ PRFLX_PORT_TYPE

const char cricket::PRFLX_PORT_TYPE = "prflx"

◆ RELAY_PORT_TYPE

const char cricket::RELAY_PORT_TYPE = "relay"

◆ RETRY_TIMEOUT

const int cricket::RETRY_TIMEOUT = 50 * 1000

◆ SSLTCP_PROTOCOL_NAME

const char cricket::SSLTCP_PROTOCOL_NAME = "ssltcp"

◆ STRONG_AND_STABLE_WRITABLE_CONNECTION_PING_INTERVAL

const int cricket::STRONG_AND_STABLE_WRITABLE_CONNECTION_PING_INTERVAL = 2500

◆ STRONG_PING_INTERVAL

const int cricket::STRONG_PING_INTERVAL = 1000 * PING_PACKET_SIZE / 1000

◆ STUN_ERROR_REASON_ALLOCATION_MISMATCH

const char cricket::STUN_ERROR_REASON_ALLOCATION_MISMATCH = "Allocation Mismatch"

◆ STUN_ERROR_REASON_BAD_REQUEST

const char cricket::STUN_ERROR_REASON_BAD_REQUEST = "Bad Request"

◆ STUN_ERROR_REASON_FORBIDDEN

const char cricket::STUN_ERROR_REASON_FORBIDDEN = "Forbidden"

◆ STUN_ERROR_REASON_ROLE_CONFLICT

const char cricket::STUN_ERROR_REASON_ROLE_CONFLICT = "Role Conflict"

◆ STUN_ERROR_REASON_SERVER_ERROR

const char cricket::STUN_ERROR_REASON_SERVER_ERROR = "Server Error"

◆ STUN_ERROR_REASON_STALE_CREDENTIALS

const char cricket::STUN_ERROR_REASON_STALE_CREDENTIALS = "Stale Credentials"

◆ STUN_ERROR_REASON_STALE_NONCE

const char cricket::STUN_ERROR_REASON_STALE_NONCE = "Stale Nonce"

◆ STUN_ERROR_REASON_TRY_ALTERNATE_SERVER

const char cricket::STUN_ERROR_REASON_TRY_ALTERNATE_SERVER = "Try Alternate Server"

◆ STUN_ERROR_REASON_UNAUTHORIZED

const char cricket::STUN_ERROR_REASON_UNAUTHORIZED = "Unauthorized"

◆ STUN_ERROR_REASON_UNKNOWN_ATTRIBUTE

const char cricket::STUN_ERROR_REASON_UNKNOWN_ATTRIBUTE

◆ STUN_ERROR_REASON_UNSUPPORTED_PROTOCOL

const char cricket::STUN_ERROR_REASON_UNSUPPORTED_PROTOCOL = "Unsupported Protocol"

◆ STUN_ERROR_REASON_WRONG_CREDENTIALS

const char cricket::STUN_ERROR_REASON_WRONG_CREDENTIALS = "Wrong Credentials"

◆ STUN_FINGERPRINT_XOR_VALUE

const uint32_t cricket::STUN_FINGERPRINT_XOR_VALUE = 0x5354554E

◆ STUN_INITIAL_RTO

const int cricket::STUN_INITIAL_RTO = 250

◆ STUN_MAX_RETRANSMISSIONS

const int cricket::STUN_MAX_RETRANSMISSIONS = 8

◆ STUN_MAX_RTO

const int cricket::STUN_MAX_RTO = 8000

◆ STUN_PORT_TYPE

const char cricket::STUN_PORT_TYPE = "stun"

◆ STUN_SERVER_PORT

const int cricket::STUN_SERVER_PORT = 3478

◆ STUN_TOTAL_TIMEOUT

const int cricket::STUN_TOTAL_TIMEOUT = 39750

◆ TCP_OPT_EOL

const uint8_t cricket::TCP_OPT_EOL = 0

◆ TCP_OPT_MSS

const uint8_t cricket::TCP_OPT_MSS = 2

◆ TCP_OPT_NOOP

const uint8_t cricket::TCP_OPT_NOOP = 1

◆ TCP_OPT_WND_SCALE

const uint8_t cricket::TCP_OPT_WND_SCALE = 3

◆ TCP_PROTOCOL_NAME

const char cricket::TCP_PROTOCOL_NAME = "tcp"

◆ TCPTYPE_ACTIVE_STR

const char cricket::TCPTYPE_ACTIVE_STR = "active"

◆ TCPTYPE_PASSIVE_STR

const char cricket::TCPTYPE_PASSIVE_STR = "passive"

◆ TCPTYPE_SIMOPEN_STR

const char cricket::TCPTYPE_SIMOPEN_STR = "so"

◆ TLS_PROTOCOL_NAME

const char cricket::TLS_PROTOCOL_NAME = "tls"

◆ TURN_MAGIC_COOKIE_VALUE

const char cricket::TURN_MAGIC_COOKIE_VALUE = { '\x72', '\xC6', '\x4B', '\xC6' }

◆ TURN_PORT_TYPE

const char cricket::TURN_PORT_TYPE

◆ TURN_SERVER_PORT

const int cricket::TURN_SERVER_PORT = 3478

◆ UDP_HEADER_SIZE

const uint32_t cricket::UDP_HEADER_SIZE = 8

◆ UDP_PROTOCOL_NAME

const char cricket::UDP_PROTOCOL_NAME = "udp"

◆ USERNAME_LENGTH

const uint32_t cricket::USERNAME_LENGTH = 16

◆ WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL

const int cricket::WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL = 900

◆ WEAK_PING_INTERVAL

const int cricket::WEAK_PING_INTERVAL = 1000 * PING_PACKET_SIZE / 10000
Generated by   doxygen 1.8.13