diff --git a/api/stats/rtcstats_objects.h b/api/stats/rtcstats_objects.h index 36013928ec..58ca165d82 100644 --- a/api/stats/rtcstats_objects.h +++ b/api/stats/rtcstats_objects.h @@ -23,6 +23,99 @@ namespace webrtc { +// https://w3c.github.io/webrtc-pc/#idl-def-rtcdatachannelstate +struct RTCDataChannelState { + static const char* const kConnecting; + static const char* const kOpen; + static const char* const kClosing; + static const char* const kClosed; +}; + +// https://w3c.github.io/webrtc-stats/#dom-rtcstatsicecandidatepairstate +struct RTCStatsIceCandidatePairState { + static const char* const kFrozen; + static const char* const kWaiting; + static const char* const kInProgress; + static const char* const kFailed; + static const char* const kSucceeded; +}; + +// https://w3c.github.io/webrtc-pc/#rtcicecandidatetype-enum +struct RTCIceCandidateType { + static const char* const kHost; + static const char* const kSrflx; + static const char* const kPrflx; + static const char* const kRelay; +}; + +// https://w3c.github.io/webrtc-pc/#idl-def-rtcdtlstransportstate +struct RTCDtlsTransportState { + static const char* const kNew; + static const char* const kConnecting; + static const char* const kConnected; + static const char* const kClosed; + static const char* const kFailed; +}; + +// `RTCRtpStreamStats::kind` is not an enum in the spec but the only valid +// values are "audio" and "video" as it comes from `MediaStreamTrack::kind`. +// https://w3c.github.io/webrtc-stats/#dom-rtcrtpstreamstats-kind +// https://w3c.github.io/mediacapture-main/#dom-mediadeviceinfo-kind +struct RTCMediaStreamTrackKind { + static const char* const kAudio; + static const char* const kVideo; +}; + +// https://w3c.github.io/webrtc-stats/#dom-rtcnetworktype +struct RTCNetworkType { + static const char* const kBluetooth; + static const char* const kCellular; + static const char* const kEthernet; + static const char* const kWifi; + static const char* const kWimax; + static const char* const kVpn; + static const char* const kUnknown; +}; + +// https://w3c.github.io/webrtc-stats/#dom-rtcqualitylimitationreason +struct RTCQualityLimitationReason { + static const char* const kNone; + static const char* const kCpu; + static const char* const kBandwidth; + static const char* const kOther; +}; + +// https://webrtc.org/experiments/rtp-hdrext/video-content-type/ +struct RTCContentType { + static const char* const kUnspecified; + static const char* const kScreenshare; +}; + +// https://w3c.github.io/webrtc-stats/#dom-rtcdtlsrole +struct RTCDtlsRole { + static const char* const kUnknown; + static const char* const kClient; + static const char* const kServer; +}; + +// https://www.w3.org/TR/webrtc/#rtcicerole +struct RTCIceRole { + static const char* const kUnknown; + static const char* const kControlled; + static const char* const kControlling; +}; + +// https://www.w3.org/TR/webrtc/#dom-rtcicetransportstate +struct RTCIceTransportState { + static const char* const kNew; + static const char* const kChecking; + static const char* const kConnected; + static const char* const kCompleted; + static const char* const kDisconnected; + static const char* const kFailed; + static const char* const kClosed; +}; + // https://w3c.github.io/webrtc-stats/#certificatestats-dict* class RTC_EXPORT RTCCertificateStats final : public RTCStats { public: @@ -38,6 +131,20 @@ class RTC_EXPORT RTCCertificateStats final : public RTCStats { RTCStatsMember issuer_certificate_id; }; +// Non standard extension mapping to rtc::AdapterType +struct RTCNetworkAdapterType { + static constexpr char kUnknown[] = "unknown"; + static constexpr char kEthernet[] = "ethernet"; + static constexpr char kWifi[] = "wifi"; + static constexpr char kCellular[] = "cellular"; + static constexpr char kLoopback[] = "loopback"; + static constexpr char kAny[] = "any"; + static constexpr char kCellular2g[] = "cellular2g"; + static constexpr char kCellular3g[] = "cellular3g"; + static constexpr char kCellular4g[] = "cellular4g"; + static constexpr char kCellular5g[] = "cellular5g"; +}; + // https://w3c.github.io/webrtc-stats/#codec-dict* class RTC_EXPORT RTCCodecStats final : public RTCStats { public: @@ -67,6 +174,7 @@ class RTC_EXPORT RTCDataChannelStats final : public RTCStats { RTCStatsMember label; RTCStatsMember protocol; RTCStatsMember data_channel_identifier; + // Enum type RTCDataChannelState. RTCStatsMember state; RTCStatsMember messages_sent; RTCStatsMember bytes_sent; @@ -86,6 +194,7 @@ class RTC_EXPORT RTCIceCandidatePairStats final : public RTCStats { RTCStatsMember transport_id; RTCStatsMember local_candidate_id; RTCStatsMember remote_candidate_id; + // Enum type RTCStatsIceCandidatePairState. RTCStatsMember state; // Obsolete: priority RTCStatsMember priority; @@ -131,6 +240,7 @@ class RTC_EXPORT RTCIceCandidateStats : public RTCStats { RTCStatsMember port; RTCStatsMember protocol; RTCStatsMember relay_protocol; + // Enum type RTCIceCandidateType. RTCStatsMember candidate_type; RTCStatsMember priority; RTCStatsMember url; @@ -138,6 +248,7 @@ class RTC_EXPORT RTCIceCandidateStats : public RTCStats { RTCStatsMember related_address; RTCStatsMember related_port; RTCStatsMember username_fragment; + // Enum type RTCIceTcpCandidateType. RTCStatsMember tcp_type; // The following metrics are NOT exposed to JavaScript. We should consider @@ -348,6 +459,7 @@ class RTC_EXPORT RTCOutboundRtpStreamStats final RTCStatsMember frames_sent; RTCStatsMember huge_frames_sent; RTCStatsMember total_packet_send_delay; + // Enum type RTCQualityLimitationReason RTCStatsMember quality_limitation_reason; RTCStatsMember> quality_limitation_durations; // https://w3c.github.io/webrtc-stats/#dom-rtcoutboundrtpstreamstats-qualitylimitationresolutionchanges @@ -464,6 +576,7 @@ class RTC_EXPORT RTCTransportStats final : public RTCStats { RTCStatsMember bytes_received; RTCStatsMember packets_received; RTCStatsMember rtcp_transport_stats_id; + // Enum type RTCDtlsTransportState. RTCStatsMember dtls_state; RTCStatsMember selected_candidate_pair_id; RTCStatsMember local_certificate_id; diff --git a/pc/peer_connection_bundle_unittest.cc b/pc/peer_connection_bundle_unittest.cc index 7edbe89316..a71b513865 100644 --- a/pc/peer_connection_bundle_unittest.cc +++ b/pc/peer_connection_bundle_unittest.cc @@ -190,8 +190,8 @@ class PeerConnectionWrapperForBundleTest : public PeerConnectionWrapper { for (auto* pair_stats : report->GetStatsOfType()) { if (*pair_stats->remote_candidate_id == matching_candidate_id) { - if (*pair_stats->state == "in-progress" || - *pair_stats->state == "succeeded") { + if (*pair_stats->state == RTCStatsIceCandidatePairState::kInProgress || + *pair_stats->state == RTCStatsIceCandidatePairState::kSucceeded) { return true; } } diff --git a/pc/rtc_stats_collector.cc b/pc/rtc_stats_collector.cc index 8cba02b5ce..48e854252a 100644 --- a/pc/rtc_stats_collector.cc +++ b/pc/rtc_stats_collector.cc @@ -166,13 +166,13 @@ std::string RTCMediaSourceStatsIDFromKindAndAttachment( const char* CandidateTypeToRTCIceCandidateType(const std::string& type) { if (type == cricket::LOCAL_PORT_TYPE) - return "host"; + return RTCIceCandidateType::kHost; if (type == cricket::STUN_PORT_TYPE) - return "srflx"; + return RTCIceCandidateType::kSrflx; if (type == cricket::PRFLX_PORT_TYPE) - return "prflx"; + return RTCIceCandidateType::kPrflx; if (type == cricket::RELAY_PORT_TYPE) - return "relay"; + return RTCIceCandidateType::kRelay; RTC_DCHECK_NOTREACHED(); return nullptr; } @@ -181,13 +181,13 @@ const char* DataStateToRTCDataChannelState( DataChannelInterface::DataState state) { switch (state) { case DataChannelInterface::kConnecting: - return "connecting"; + return RTCDataChannelState::kConnecting; case DataChannelInterface::kOpen: - return "open"; + return RTCDataChannelState::kOpen; case DataChannelInterface::kClosing: - return "closing"; + return RTCDataChannelState::kClosing; case DataChannelInterface::kClosed: - return "closed"; + return RTCDataChannelState::kClosed; default: RTC_DCHECK_NOTREACHED(); return nullptr; @@ -198,13 +198,13 @@ const char* IceCandidatePairStateToRTCStatsIceCandidatePairState( cricket::IceCandidatePairState state) { switch (state) { case cricket::IceCandidatePairState::WAITING: - return "waiting"; + return RTCStatsIceCandidatePairState::kWaiting; case cricket::IceCandidatePairState::IN_PROGRESS: - return "in-progress"; + return RTCStatsIceCandidatePairState::kInProgress; case cricket::IceCandidatePairState::SUCCEEDED: - return "succeeded"; + return RTCStatsIceCandidatePairState::kSucceeded; case cricket::IceCandidatePairState::FAILED: - return "failed"; + return RTCStatsIceCandidatePairState::kFailed; default: RTC_DCHECK_NOTREACHED(); return nullptr; @@ -214,11 +214,11 @@ const char* IceCandidatePairStateToRTCStatsIceCandidatePairState( const char* IceRoleToRTCIceRole(cricket::IceRole role) { switch (role) { case cricket::IceRole::ICEROLE_UNKNOWN: - return "unknown"; + return RTCIceRole::kUnknown; case cricket::IceRole::ICEROLE_CONTROLLED: - return "controlled"; + return RTCIceRole::kControlled; case cricket::IceRole::ICEROLE_CONTROLLING: - return "controlling"; + return RTCIceRole::kControlling; default: RTC_DCHECK_NOTREACHED(); return nullptr; @@ -229,15 +229,15 @@ const char* DtlsTransportStateToRTCDtlsTransportState( DtlsTransportState state) { switch (state) { case DtlsTransportState::kNew: - return "new"; + return RTCDtlsTransportState::kNew; case DtlsTransportState::kConnecting: - return "connecting"; + return RTCDtlsTransportState::kConnecting; case DtlsTransportState::kConnected: - return "connected"; + return RTCDtlsTransportState::kConnected; case DtlsTransportState::kClosed: - return "closed"; + return RTCDtlsTransportState::kClosed; case DtlsTransportState::kFailed: - return "failed"; + return RTCDtlsTransportState::kFailed; default: RTC_CHECK_NOTREACHED(); return nullptr; @@ -247,19 +247,19 @@ const char* DtlsTransportStateToRTCDtlsTransportState( const char* IceTransportStateToRTCIceTransportState(IceTransportState state) { switch (state) { case IceTransportState::kNew: - return "new"; + return RTCIceTransportState::kNew; case IceTransportState::kChecking: - return "checking"; + return RTCIceTransportState::kChecking; case IceTransportState::kConnected: - return "connected"; + return RTCIceTransportState::kConnected; case IceTransportState::kCompleted: - return "completed"; + return RTCIceTransportState::kCompleted; case IceTransportState::kFailed: - return "failed"; + return RTCIceTransportState::kFailed; case IceTransportState::kDisconnected: - return "disconnected"; + return RTCIceTransportState::kDisconnected; case IceTransportState::kClosed: - return "closed"; + return RTCIceTransportState::kClosed; default: RTC_CHECK_NOTREACHED(); return nullptr; @@ -273,17 +273,17 @@ const char* NetworkTypeToStatsType(rtc::AdapterType type) { case rtc::ADAPTER_TYPE_CELLULAR_3G: case rtc::ADAPTER_TYPE_CELLULAR_4G: case rtc::ADAPTER_TYPE_CELLULAR_5G: - return "cellular"; + return RTCNetworkType::kCellular; case rtc::ADAPTER_TYPE_ETHERNET: - return "ethernet"; + return RTCNetworkType::kEthernet; case rtc::ADAPTER_TYPE_WIFI: - return "wifi"; + return RTCNetworkType::kWifi; case rtc::ADAPTER_TYPE_VPN: - return "vpn"; + return RTCNetworkType::kVpn; case rtc::ADAPTER_TYPE_UNKNOWN: case rtc::ADAPTER_TYPE_LOOPBACK: case rtc::ADAPTER_TYPE_ANY: - return "unknown"; + return RTCNetworkType::kUnknown; } RTC_DCHECK_NOTREACHED(); return nullptr; @@ -292,25 +292,25 @@ const char* NetworkTypeToStatsType(rtc::AdapterType type) { absl::string_view NetworkTypeToStatsNetworkAdapterType(rtc::AdapterType type) { switch (type) { case rtc::ADAPTER_TYPE_CELLULAR: - return "cellular"; + return RTCNetworkAdapterType::kCellular; case rtc::ADAPTER_TYPE_CELLULAR_2G: - return "cellular2g"; + return RTCNetworkAdapterType::kCellular2g; case rtc::ADAPTER_TYPE_CELLULAR_3G: - return "cellular3g"; + return RTCNetworkAdapterType::kCellular3g; case rtc::ADAPTER_TYPE_CELLULAR_4G: - return "cellular4g"; + return RTCNetworkAdapterType::kCellular4g; case rtc::ADAPTER_TYPE_CELLULAR_5G: - return "cellular5g"; + return RTCNetworkAdapterType::kCellular5g; case rtc::ADAPTER_TYPE_ETHERNET: - return "ethernet"; + return RTCNetworkAdapterType::kEthernet; case rtc::ADAPTER_TYPE_WIFI: - return "wifi"; + return RTCNetworkAdapterType::kWifi; case rtc::ADAPTER_TYPE_UNKNOWN: - return "unknown"; + return RTCNetworkAdapterType::kUnknown; case rtc::ADAPTER_TYPE_LOOPBACK: - return "loopback"; + return RTCNetworkAdapterType::kLoopback; case rtc::ADAPTER_TYPE_ANY: - return "any"; + return RTCNetworkAdapterType::kAny; case rtc::ADAPTER_TYPE_VPN: /* should not be handled here. Vpn is modelled as a bool */ break; @@ -323,13 +323,13 @@ const char* QualityLimitationReasonToRTCQualityLimitationReason( QualityLimitationReason reason) { switch (reason) { case QualityLimitationReason::kNone: - return "none"; + return RTCQualityLimitationReason::kNone; case QualityLimitationReason::kCpu: - return "cpu"; + return RTCQualityLimitationReason::kCpu; case QualityLimitationReason::kBandwidth: - return "bandwidth"; + return RTCQualityLimitationReason::kBandwidth; case QualityLimitationReason::kOther: - return "other"; + return RTCQualityLimitationReason::kOther; } RTC_CHECK_NOTREACHED(); } @@ -661,7 +661,7 @@ CreateInboundRTPStreamStatsFromVideoReceiverInfo( // TODO(bugs.webrtc.org/10529): When info's `content_info` is optional // support the "unspecified" value. if (video_receiver_info.content_type == VideoContentType::SCREENSHARE) - inbound_video->content_type = "screenshare"; + inbound_video->content_type = RTCContentType::kScreenshare; if (!video_receiver_info.decoder_implementation_name.empty()) { inbound_video->decoder_implementation = video_receiver_info.decoder_implementation_name; @@ -802,7 +802,7 @@ CreateOutboundRTPStreamStatsFromVideoSenderInfo( // TODO(https://crbug.com/webrtc/10529): When info's `content_info` is // optional, support the "unspecified" value. if (video_sender_info.content_type == VideoContentType::SCREENSHARE) - outbound_video->content_type = "screenshare"; + outbound_video->content_type = RTCContentType::kScreenshare; if (!video_sender_info.encoder_implementation_name.empty()) { outbound_video->encoder_implementation = video_sender_info.encoder_implementation_name; @@ -1918,10 +1918,11 @@ void RTCStatsCollector::ProduceTransportStats_n( } if (channel_stats.dtls_role) { - transport_stats->dtls_role = - *channel_stats.dtls_role == rtc::SSL_CLIENT ? "client" : "server"; + transport_stats->dtls_role = *channel_stats.dtls_role == rtc::SSL_CLIENT + ? webrtc::RTCDtlsRole::kClient + : webrtc::RTCDtlsRole::kServer; } else { - transport_stats->dtls_role = "unknown"; + transport_stats->dtls_role = webrtc::RTCDtlsRole::kUnknown; } if (channel_stats.ssl_cipher_suite != rtc::kTlsNullWithNullNull && diff --git a/pc/rtc_stats_collector_unittest.cc b/pc/rtc_stats_collector_unittest.cc index a9f326f96a..a8111bf8b2 100644 --- a/pc/rtc_stats_collector_unittest.cc +++ b/pc/rtc_stats_collector_unittest.cc @@ -1652,7 +1652,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidateStats) { expected_a_local_host.candidate_type = "host"; expected_a_local_host.priority = 0; expected_a_local_host.vpn = true; - expected_a_local_host.network_adapter_type = "ethernet"; + expected_a_local_host.network_adapter_type = RTCNetworkAdapterType::kEthernet; expected_a_local_host.foundation = "foundationIsAString"; expected_a_local_host.username_fragment = "iceusernamefragment"; @@ -1685,7 +1685,8 @@ TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidateStats) { expected_a_local_prflx.candidate_type = "prflx"; expected_a_local_prflx.priority = 2; expected_a_local_prflx.vpn = false; - expected_a_local_prflx.network_adapter_type = "cellular2g"; + expected_a_local_prflx.network_adapter_type = + RTCNetworkAdapterType::kCellular2g; expected_a_local_prflx.foundation = "foundationIsAString"; expected_a_local_prflx.username_fragment = "iceusernamefragment"; @@ -1723,7 +1724,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidateStats) { expected_a_local_relay.priority = 1; expected_a_local_relay.url = "turn:url1"; expected_a_local_relay.vpn = false; - expected_a_local_relay.network_adapter_type = "unknown"; + expected_a_local_relay.network_adapter_type = RTCNetworkAdapterType::kUnknown; expected_a_local_relay.foundation = "foundationIsAString"; expected_a_local_relay.username_fragment = "iceusernamefragment"; @@ -1744,7 +1745,8 @@ TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidateStats) { expected_a_local_relay_prflx.candidate_type = "prflx"; expected_a_local_relay_prflx.priority = 1; expected_a_local_relay_prflx.vpn = false; - expected_a_local_relay_prflx.network_adapter_type = "unknown"; + expected_a_local_relay_prflx.network_adapter_type = + RTCNetworkAdapterType::kUnknown; expected_a_local_relay_prflx.foundation = "foundationIsAString"; expected_a_local_relay_prflx.username_fragment = "iceusernamefragment"; @@ -1765,7 +1767,8 @@ TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidateStats) { expected_a_local_host_not_paired.candidate_type = "host"; expected_a_local_host_not_paired.priority = 0; expected_a_local_host_not_paired.vpn = true; - expected_a_local_host_not_paired.network_adapter_type = "ethernet"; + expected_a_local_host_not_paired.network_adapter_type = + RTCNetworkAdapterType::kEthernet; expected_a_local_host_not_paired.foundation = "foundationIsAString"; expected_a_local_host_not_paired.username_fragment = "iceusernamefragment"; @@ -1784,7 +1787,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidateStats) { expected_b_local.candidate_type = "host"; expected_b_local.priority = 42; expected_b_local.vpn = false; - expected_b_local.network_adapter_type = "wifi"; + expected_b_local.network_adapter_type = RTCNetworkAdapterType::kWifi; expected_b_local.foundation = "foundationIsAString"; expected_b_local.username_fragment = "iceusernamefragment"; @@ -1941,7 +1944,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidatePairStats) { "Ttransport" + rtc::ToString(cricket::ICE_CANDIDATE_COMPONENT_RTP); expected_pair.local_candidate_id = "I" + local_candidate->id(); expected_pair.remote_candidate_id = "I" + remote_candidate->id(); - expected_pair.state = "in-progress"; + expected_pair.state = RTCStatsIceCandidatePairState::kInProgress; expected_pair.priority = 5555; expected_pair.nominated = false; expected_pair.writable = true; @@ -2040,7 +2043,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidatePairStats) { expected_local_candidate.foundation = "foundationIsAString"; expected_local_candidate.username_fragment = "local_iceusernamefragment"; expected_local_candidate.vpn = false; - expected_local_candidate.network_adapter_type = "wifi"; + expected_local_candidate.network_adapter_type = RTCNetworkAdapterType::kWifi; ASSERT_TRUE(report->Get(expected_local_candidate.id())); EXPECT_EQ(expected_local_candidate, report->Get(expected_local_candidate.id()) @@ -2748,12 +2751,12 @@ TEST_F(RTCStatsCollectorTest, CollectRTCTransportStats) { expected_rtp_transport.packets_sent = 1; expected_rtp_transport.bytes_received = 1337; expected_rtp_transport.packets_received = 4; - expected_rtp_transport.dtls_state = "new"; - expected_rtp_transport.dtls_role = "unknown"; + expected_rtp_transport.dtls_state = RTCDtlsTransportState::kNew; + expected_rtp_transport.dtls_role = RTCDtlsRole::kUnknown; expected_rtp_transport.selected_candidate_pair_changes = 1; - expected_rtp_transport.ice_role = "unknown"; + expected_rtp_transport.ice_role = RTCIceRole::kUnknown; expected_rtp_transport.ice_local_username_fragment = "thelocalufrag"; - expected_rtp_transport.ice_state = "new"; + expected_rtp_transport.ice_state = RTCIceTransportState::kNew; ASSERT_TRUE(report->Get(expected_rtp_transport.id())); EXPECT_EQ( @@ -2796,12 +2799,12 @@ TEST_F(RTCStatsCollectorTest, CollectRTCTransportStats) { expected_rtcp_transport.packets_sent = 1; expected_rtcp_transport.bytes_received = 42; expected_rtcp_transport.packets_received = 4; - expected_rtcp_transport.dtls_state = "connecting"; - expected_rtcp_transport.dtls_role = "unknown"; + expected_rtcp_transport.dtls_state = RTCDtlsTransportState::kConnecting; + expected_rtcp_transport.dtls_role = RTCDtlsRole::kUnknown; expected_rtcp_transport.selected_candidate_pair_changes = 0; - expected_rtcp_transport.ice_role = "unknown"; + expected_rtcp_transport.ice_role = RTCIceRole::kUnknown; expected_rtcp_transport.ice_local_username_fragment = "thelocalufrag"; - expected_rtcp_transport.ice_state = "checking"; + expected_rtcp_transport.ice_state = RTCIceTransportState::kChecking; expected_rtp_transport.rtcp_transport_stats_id = expected_rtcp_transport.id(); ASSERT_TRUE(report->Get(expected_rtp_transport.id())); @@ -2917,19 +2920,19 @@ TEST_F(RTCStatsCollectorTest, CollectRTCTransportStatsWithCrypto) { RTCTransportStats expected_rtp_transport( "Ttransport" + rtc::ToString(cricket::ICE_CANDIDATE_COMPONENT_RTP), report->timestamp()); - expected_rtp_transport.dtls_state = "connected"; + expected_rtp_transport.dtls_state = RTCDtlsTransportState::kConnected; expected_rtp_transport.selected_candidate_pair_changes = 1; - expected_rtp_transport.ice_role = "unknown"; + expected_rtp_transport.ice_role = RTCIceRole::kUnknown; expected_rtp_transport.bytes_sent = 0; expected_rtp_transport.bytes_received = 0; expected_rtp_transport.packets_sent = 0; expected_rtp_transport.packets_received = 0; - expected_rtp_transport.ice_role = "controlling"; + expected_rtp_transport.ice_role = RTCIceRole::kControlling; expected_rtp_transport.ice_local_username_fragment = "thelocalufrag"; expected_rtp_transport.ice_state = "connected"; // Crypto parameters expected_rtp_transport.tls_version = "0203"; - expected_rtp_transport.dtls_role = "client"; + expected_rtp_transport.dtls_role = RTCDtlsRole::kClient; expected_rtp_transport.dtls_cipher = "TLS_RSA_WITH_AES_128_CBC_SHA"; expected_rtp_transport.srtp_cipher = "AES_CM_128_HMAC_SHA1_80"; diff --git a/stats/rtcstats_objects.cc b/stats/rtcstats_objects.cc index 31720ad33f..67cb1c58f2 100644 --- a/stats/rtcstats_objects.cc +++ b/stats/rtcstats_objects.cc @@ -17,6 +17,70 @@ namespace webrtc { +const char* const RTCDataChannelState::kConnecting = "connecting"; +const char* const RTCDataChannelState::kOpen = "open"; +const char* const RTCDataChannelState::kClosing = "closing"; +const char* const RTCDataChannelState::kClosed = "closed"; + +const char* const RTCStatsIceCandidatePairState::kFrozen = "frozen"; +const char* const RTCStatsIceCandidatePairState::kWaiting = "waiting"; +const char* const RTCStatsIceCandidatePairState::kInProgress = "in-progress"; +const char* const RTCStatsIceCandidatePairState::kFailed = "failed"; +const char* const RTCStatsIceCandidatePairState::kSucceeded = "succeeded"; + +// Strings defined in https://tools.ietf.org/html/rfc5245. +const char* const RTCIceCandidateType::kHost = "host"; +const char* const RTCIceCandidateType::kSrflx = "srflx"; +const char* const RTCIceCandidateType::kPrflx = "prflx"; +const char* const RTCIceCandidateType::kRelay = "relay"; + +const char* const RTCDtlsTransportState::kNew = "new"; +const char* const RTCDtlsTransportState::kConnecting = "connecting"; +const char* const RTCDtlsTransportState::kConnected = "connected"; +const char* const RTCDtlsTransportState::kClosed = "closed"; +const char* const RTCDtlsTransportState::kFailed = "failed"; + +const char* const RTCMediaStreamTrackKind::kAudio = "audio"; +const char* const RTCMediaStreamTrackKind::kVideo = "video"; + +// https://w3c.github.io/webrtc-stats/#dom-rtcnetworktype +const char* const RTCNetworkType::kBluetooth = "bluetooth"; +const char* const RTCNetworkType::kCellular = "cellular"; +const char* const RTCNetworkType::kEthernet = "ethernet"; +const char* const RTCNetworkType::kWifi = "wifi"; +const char* const RTCNetworkType::kWimax = "wimax"; +const char* const RTCNetworkType::kVpn = "vpn"; +const char* const RTCNetworkType::kUnknown = "unknown"; + +// https://w3c.github.io/webrtc-stats/#dom-rtcqualitylimitationreason +const char* const RTCQualityLimitationReason::kNone = "none"; +const char* const RTCQualityLimitationReason::kCpu = "cpu"; +const char* const RTCQualityLimitationReason::kBandwidth = "bandwidth"; +const char* const RTCQualityLimitationReason::kOther = "other"; + +// https://webrtc.org/experiments/rtp-hdrext/video-content-type/ +const char* const RTCContentType::kUnspecified = "unspecified"; +const char* const RTCContentType::kScreenshare = "screenshare"; + +// https://w3c.github.io/webrtc-stats/#dom-rtcdtlsrole +const char* const RTCDtlsRole::kUnknown = "unknown"; +const char* const RTCDtlsRole::kClient = "client"; +const char* const RTCDtlsRole::kServer = "server"; + +// https://www.w3.org/TR/webrtc/#rtcicerole +const char* const RTCIceRole::kUnknown = "unknown"; +const char* const RTCIceRole::kControlled = "controlled"; +const char* const RTCIceRole::kControlling = "controlling"; + +// https://www.w3.org/TR/webrtc/#dom-rtcicetransportstate +const char* const RTCIceTransportState::kNew = "new"; +const char* const RTCIceTransportState::kChecking = "checking"; +const char* const RTCIceTransportState::kConnected = "connected"; +const char* const RTCIceTransportState::kCompleted = "completed"; +const char* const RTCIceTransportState::kDisconnected = "disconnected"; +const char* const RTCIceTransportState::kFailed = "failed"; +const char* const RTCIceTransportState::kClosed = "closed"; + // clang-format off WEBRTC_RTCSTATS_IMPL(RTCCertificateStats, RTCStats, "certificate", &fingerprint, diff --git a/test/pc/e2e/analyzer/audio/default_audio_quality_analyzer.cc b/test/pc/e2e/analyzer/audio/default_audio_quality_analyzer.cc index 09fd7c8a82..49e165795a 100644 --- a/test/pc/e2e/analyzer/audio/default_audio_quality_analyzer.cc +++ b/test/pc/e2e/analyzer/audio/default_audio_quality_analyzer.cc @@ -42,7 +42,8 @@ void DefaultAudioQualityAnalyzer::OnStatsReports( auto stats = report->GetStatsOfType(); for (auto& stat : stats) { - if (!stat->kind.is_defined() || !(*stat->kind == "audio")) { + if (!stat->kind.is_defined() || + !(*stat->kind == RTCMediaStreamTrackKind::kAudio)) { continue; } diff --git a/test/pc/e2e/analyzer/video/video_quality_metrics_reporter.cc b/test/pc/e2e/analyzer/video/video_quality_metrics_reporter.cc index 817b3caad0..224eb0c59f 100644 --- a/test/pc/e2e/analyzer/video/video_quality_metrics_reporter.cc +++ b/test/pc/e2e/analyzer/video/video_quality_metrics_reporter.cc @@ -74,7 +74,7 @@ void VideoQualityMetricsReporter::OnStatsReports( if (!s->kind.is_defined()) { continue; } - if (!(*s->kind == "video")) { + if (!(*s->kind == RTCMediaStreamTrackKind::kVideo)) { continue; } if (s->timestamp() > sample.sample_time) { diff --git a/test/pc/e2e/cross_media_metrics_reporter.cc b/test/pc/e2e/cross_media_metrics_reporter.cc index aad5946c9f..549eafd95a 100644 --- a/test/pc/e2e/cross_media_metrics_reporter.cc +++ b/test/pc/e2e/cross_media_metrics_reporter.cc @@ -71,7 +71,7 @@ void CrossMediaMetricsReporter::OnStatsReports( *audio_stat->kind != *video_stat->kind) << "Sync group should consist of one audio and one video stream."; - if (*audio_stat->kind == "video") { + if (*audio_stat->kind == RTCMediaStreamTrackKind::kVideo) { std::swap(audio_stat, video_stat); } // Stream labels of a sync group are same for all polls, so we need it add