mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-12 21:30:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

[Stats] Migrate from the RTCStatsMember type alias to absl::optional.

Browse source 
With this CL, the only usage of RTCStatsMember within WebRTC is the
actual type alias declaration. It's not referenced anywhere anymore.

This allows us to deleting the type alias, but let's do that in a
standalone CL in case it gets reverted.

Bug: webrtc:15164
Change-Id: I766d07abb62b5ddd524859b8ed749394fc439e52
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/335621
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Evan Shrubsole <eshr@google.com>
Commit-Queue: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41612}
This commit is contained in:
Henrik Boström 2024-01-22 13:51:36 +01:00 committed by WebRTC LUCI CQ
parent a310d78662
commit ac58a334f7
10 changed files with 257 additions and 245 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
api/stats/rtc_stats.h
View file

@ -20,6 +20,7 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "absl/types/optional.h"
#include "api/stats/attribute.h" #include "api/stats/attribute.h"
#include "api/units/timestamp.h" #include "api/units/timestamp.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
@ -38,8 +39,8 @@ namespace webrtc {
// Use the `WEBRTC_RTCSTATS_IMPL` macro when implementing subclasses, see macro // Use the `WEBRTC_RTCSTATS_IMPL` macro when implementing subclasses, see macro
// for details. // for details.
// //
// Derived classes list their dictionary attributes (RTCStatsMember<T> to soon // Derived classes list their dictionary attributes, absl::optional<T>, as
// be replaced by absl::optional<T>) as public fields, allowing the following: // public fields, allowing the following:
// //
// RTCFooStats foo("fooId", Timestamp::Micros(GetCurrentTime())); // RTCFooStats foo("fooId", Timestamp::Micros(GetCurrentTime()));
// foo.bar = 42; // foo.bar = 42;
@ -51,7 +52,7 @@ namespace webrtc {
// iteration: // iteration:
// //
// for (const auto& attribute : foo.Attributes()) { // for (const auto& attribute : foo.Attributes()) {
// printf("%s = %s\n", attribute.name(), attribute.ValueToString().c_str()); // printf("%s = %s\n", attribute.name(), attribute.ToString().c_str());
// } // }
class RTC_EXPORT RTCStats { class RTC_EXPORT RTCStats {
public: public:
@ -72,12 +73,12 @@ class RTC_EXPORT RTCStats {
// metrics as viewed via the Attribute wrapper. // metrics as viewed via the Attribute wrapper.
std::vector<Attribute> Attributes() const; std::vector<Attribute> Attributes() const;
template <typename T> template <typename T>
Attribute GetAttribute(const RTCStatsMember<T>& stat) const { Attribute GetAttribute(const absl::optional<T>& stat) const {
for (const auto& attribute : Attributes()) { for (const auto& attribute : Attributes()) {
if (!attribute.holds_alternative<T>()) { if (!attribute.holds_alternative<T>()) {
continue; continue;
} }
if (absl::get<const RTCStatsMember<T>*>(attribute.as_variant()) == if (absl::get<const absl::optional<T>*>(attribute.as_variant()) ==
&stat) { &stat) {
return attribute; return attribute;
} }
@ -135,8 +136,8 @@ class RTC_EXPORT RTCStats {
// //
// RTCFooStats(const std::string& id, Timestamp timestamp); // RTCFooStats(const std::string& id, Timestamp timestamp);
// //
// RTCStatsMember<int32_t> foo; // absl::optional<int32_t> foo;
// RTCStatsMember<int32_t> bar; // absl::optional<int32_t> bar;
// }; // };
// //
// rtcfoostats.cc: // rtcfoostats.cc:

415
api/stats/rtcstats_objects.h
View file

@ -18,6 +18,7 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "absl/types/optional.h"
#include "api/stats/rtc_stats.h" #include "api/stats/rtc_stats.h"
#include "rtc_base/system/rtc_export.h" #include "rtc_base/system/rtc_export.h"
@ -30,10 +31,10 @@ class RTC_EXPORT RTCCertificateStats final : public RTCStats {
RTCCertificateStats(std::string id, Timestamp timestamp); RTCCertificateStats(std::string id, Timestamp timestamp);
~RTCCertificateStats() override; ~RTCCertificateStats() override;
RTCStatsMember<std::string> fingerprint; absl::optional<std::string> fingerprint;
RTCStatsMember<std::string> fingerprint_algorithm; absl::optional<std::string> fingerprint_algorithm;
RTCStatsMember<std::string> base64_certificate; absl::optional<std::string> base64_certificate;
RTCStatsMember<std::string> issuer_certificate_id; absl::optional<std::string> issuer_certificate_id;
}; };
// https://w3c.github.io/webrtc-stats/#codec-dict* // https://w3c.github.io/webrtc-stats/#codec-dict*
@ -43,12 +44,12 @@ class RTC_EXPORT RTCCodecStats final : public RTCStats {
RTCCodecStats(std::string id, Timestamp timestamp); RTCCodecStats(std::string id, Timestamp timestamp);
~RTCCodecStats() override; ~RTCCodecStats() override;
RTCStatsMember<std::string> transport_id; absl::optional<std::string> transport_id;
RTCStatsMember<uint32_t> payload_type; absl::optional<uint32_t> payload_type;
RTCStatsMember<std::string> mime_type; absl::optional<std::string> mime_type;
RTCStatsMember<uint32_t> clock_rate; absl::optional<uint32_t> clock_rate;
RTCStatsMember<uint32_t> channels; absl::optional<uint32_t> channels;
RTCStatsMember<std::string> sdp_fmtp_line; absl::optional<std::string> sdp_fmtp_line;
}; };
// https://w3c.github.io/webrtc-stats/#dcstats-dict* // https://w3c.github.io/webrtc-stats/#dcstats-dict*
@ -58,14 +59,14 @@ class RTC_EXPORT RTCDataChannelStats final : public RTCStats {
RTCDataChannelStats(std::string id, Timestamp timestamp); RTCDataChannelStats(std::string id, Timestamp timestamp);
~RTCDataChannelStats() override; ~RTCDataChannelStats() override;
RTCStatsMember<std::string> label; absl::optional<std::string> label;
RTCStatsMember<std::string> protocol; absl::optional<std::string> protocol;
RTCStatsMember<int32_t> data_channel_identifier; absl::optional<int32_t> data_channel_identifier;
RTCStatsMember<std::string> state; absl::optional<std::string> state;
RTCStatsMember<uint32_t> messages_sent; absl::optional<uint32_t> messages_sent;
RTCStatsMember<uint64_t> bytes_sent; absl::optional<uint64_t> bytes_sent;
RTCStatsMember<uint32_t> messages_received; absl::optional<uint32_t> messages_received;
RTCStatsMember<uint64_t> bytes_received; absl::optional<uint64_t> bytes_received;
}; };
// https://w3c.github.io/webrtc-stats/#candidatepair-dict* // https://w3c.github.io/webrtc-stats/#candidatepair-dict*
@ -75,35 +76,35 @@ class RTC_EXPORT RTCIceCandidatePairStats final : public RTCStats {
RTCIceCandidatePairStats(std::string id, Timestamp timestamp); RTCIceCandidatePairStats(std::string id, Timestamp timestamp);
~RTCIceCandidatePairStats() override; ~RTCIceCandidatePairStats() override;
RTCStatsMember<std::string> transport_id; absl::optional<std::string> transport_id;
RTCStatsMember<std::string> local_candidate_id; absl::optional<std::string> local_candidate_id;
RTCStatsMember<std::string> remote_candidate_id; absl::optional<std::string> remote_candidate_id;
RTCStatsMember<std::string> state; absl::optional<std::string> state;
// Obsolete: priority // Obsolete: priority
RTCStatsMember<uint64_t> priority; absl::optional<uint64_t> priority;
RTCStatsMember<bool> nominated; absl::optional<bool> nominated;
// `writable` does not exist in the spec and old comments suggest it used to // `writable` does not exist in the spec and old comments suggest it used to
// exist but was incorrectly implemented. // exist but was incorrectly implemented.
// TODO(https://crbug.com/webrtc/14171): Standardize and/or modify // TODO(https://crbug.com/webrtc/14171): Standardize and/or modify
// implementation. // implementation.
RTCStatsMember<bool> writable; absl::optional<bool> writable;
RTCStatsMember<uint64_t> packets_sent; absl::optional<uint64_t> packets_sent;
RTCStatsMember<uint64_t> packets_received; absl::optional<uint64_t> packets_received;
RTCStatsMember<uint64_t> bytes_sent; absl::optional<uint64_t> bytes_sent;
RTCStatsMember<uint64_t> bytes_received; absl::optional<uint64_t> bytes_received;
RTCStatsMember<double> total_round_trip_time; absl::optional<double> total_round_trip_time;
RTCStatsMember<double> current_round_trip_time; absl::optional<double> current_round_trip_time;
RTCStatsMember<double> available_outgoing_bitrate; absl::optional<double> available_outgoing_bitrate;
RTCStatsMember<double> available_incoming_bitrate; absl::optional<double> available_incoming_bitrate;
RTCStatsMember<uint64_t> requests_received; absl::optional<uint64_t> requests_received;
RTCStatsMember<uint64_t> requests_sent; absl::optional<uint64_t> requests_sent;
RTCStatsMember<uint64_t> responses_received; absl::optional<uint64_t> responses_received;
RTCStatsMember<uint64_t> responses_sent; absl::optional<uint64_t> responses_sent;
RTCStatsMember<uint64_t> consent_requests_sent; absl::optional<uint64_t> consent_requests_sent;
RTCStatsMember<uint64_t> packets_discarded_on_send; absl::optional<uint64_t> packets_discarded_on_send;
RTCStatsMember<uint64_t> bytes_discarded_on_send; absl::optional<uint64_t> bytes_discarded_on_send;
RTCStatsMember<double> last_packet_received_timestamp; absl::optional<double> last_packet_received_timestamp;
RTCStatsMember<double> last_packet_sent_timestamp; absl::optional<double> last_packet_sent_timestamp;
}; };
// https://w3c.github.io/webrtc-stats/#icecandidate-dict* // https://w3c.github.io/webrtc-stats/#icecandidate-dict*
@ -112,28 +113,28 @@ class RTC_EXPORT RTCIceCandidateStats : public RTCStats {
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
~RTCIceCandidateStats() override; ~RTCIceCandidateStats() override;
RTCStatsMember<std::string> transport_id; absl::optional<std::string> transport_id;
// Obsolete: is_remote // Obsolete: is_remote
RTCStatsMember<bool> is_remote; absl::optional<bool> is_remote;
RTCStatsMember<std::string> network_type; absl::optional<std::string> network_type;
RTCStatsMember<std::string> ip; absl::optional<std::string> ip;
RTCStatsMember<std::string> address; absl::optional<std::string> address;
RTCStatsMember<int32_t> port; absl::optional<int32_t> port;
RTCStatsMember<std::string> protocol; absl::optional<std::string> protocol;
RTCStatsMember<std::string> relay_protocol; absl::optional<std::string> relay_protocol;
RTCStatsMember<std::string> candidate_type; absl::optional<std::string> candidate_type;
RTCStatsMember<int32_t> priority; absl::optional<int32_t> priority;
RTCStatsMember<std::string> url; absl::optional<std::string> url;
RTCStatsMember<std::string> foundation; absl::optional<std::string> foundation;
RTCStatsMember<std::string> related_address; absl::optional<std::string> related_address;
RTCStatsMember<int32_t> related_port; absl::optional<int32_t> related_port;
RTCStatsMember<std::string> username_fragment; absl::optional<std::string> username_fragment;
RTCStatsMember<std::string> tcp_type; absl::optional<std::string> tcp_type;
// The following metrics are NOT exposed to JavaScript. We should consider // The following metrics are NOT exposed to JavaScript. We should consider
// standardizing or removing them. // standardizing or removing them.
RTCStatsMember<bool> vpn; absl::optional<bool> vpn;
RTCStatsMember<std::string> network_adapter_type; absl::optional<std::string> network_adapter_type;
protected: protected:
RTCIceCandidateStats(std::string id, Timestamp timestamp, bool is_remote); RTCIceCandidateStats(std::string id, Timestamp timestamp, bool is_remote);
@ -168,8 +169,8 @@ class RTC_EXPORT RTCPeerConnectionStats final : public RTCStats {
RTCPeerConnectionStats(std::string id, Timestamp timestamp); RTCPeerConnectionStats(std::string id, Timestamp timestamp);
~RTCPeerConnectionStats() override; ~RTCPeerConnectionStats() override;
RTCStatsMember<uint32_t> data_channels_opened; absl::optional<uint32_t> data_channels_opened;
RTCStatsMember<uint32_t> data_channels_closed; absl::optional<uint32_t> data_channels_closed;
}; };
// https://w3c.github.io/webrtc-stats/#streamstats-dict* // https://w3c.github.io/webrtc-stats/#streamstats-dict*
@ -178,10 +179,10 @@ class RTC_EXPORT RTCRtpStreamStats : public RTCStats {
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
~RTCRtpStreamStats() override; ~RTCRtpStreamStats() override;
RTCStatsMember<uint32_t> ssrc; absl::optional<uint32_t> ssrc;
RTCStatsMember<std::string> kind; absl::optional<std::string> kind;
RTCStatsMember<std::string> transport_id; absl::optional<std::string> transport_id;
RTCStatsMember<std::string> codec_id; absl::optional<std::string> codec_id;
protected: protected:
RTCRtpStreamStats(std::string id, Timestamp timestamp); RTCRtpStreamStats(std::string id, Timestamp timestamp);
@ -193,8 +194,8 @@ class RTC_EXPORT RTCReceivedRtpStreamStats : public RTCRtpStreamStats {
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
~RTCReceivedRtpStreamStats() override; ~RTCReceivedRtpStreamStats() override;
RTCStatsMember<double> jitter; absl::optional<double> jitter;
RTCStatsMember<int32_t> packets_lost; // Signed per RFC 3550 absl::optional<int32_t> packets_lost; // Signed per RFC 3550
protected: protected:
RTCReceivedRtpStreamStats(std::string id, Timestamp timestamp); RTCReceivedRtpStreamStats(std::string id, Timestamp timestamp);
@ -206,8 +207,8 @@ class RTC_EXPORT RTCSentRtpStreamStats : public RTCRtpStreamStats {
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
~RTCSentRtpStreamStats() override; ~RTCSentRtpStreamStats() override;
RTCStatsMember<uint64_t> packets_sent; absl::optional<uint64_t> packets_sent;
RTCStatsMember<uint64_t> bytes_sent; absl::optional<uint64_t> bytes_sent;
protected: protected:
RTCSentRtpStreamStats(std::string id, Timestamp timestamp); RTCSentRtpStreamStats(std::string id, Timestamp timestamp);
@ -221,51 +222,51 @@ class RTC_EXPORT RTCInboundRtpStreamStats final
RTCInboundRtpStreamStats(std::string id, Timestamp timestamp); RTCInboundRtpStreamStats(std::string id, Timestamp timestamp);
~RTCInboundRtpStreamStats() override; ~RTCInboundRtpStreamStats() override;
RTCStatsMember<std::string> playout_id; absl::optional<std::string> playout_id;
RTCStatsMember<std::string> track_identifier; absl::optional<std::string> track_identifier;
RTCStatsMember<std::string> mid; absl::optional<std::string> mid;
RTCStatsMember<std::string> remote_id; absl::optional<std::string> remote_id;
RTCStatsMember<uint32_t> packets_received; absl::optional<uint32_t> packets_received;
RTCStatsMember<uint64_t> packets_discarded; absl::optional<uint64_t> packets_discarded;
RTCStatsMember<uint64_t> fec_packets_received; absl::optional<uint64_t> fec_packets_received;
RTCStatsMember<uint64_t> fec_bytes_received; absl::optional<uint64_t> fec_bytes_received;
RTCStatsMember<uint64_t> fec_packets_discarded; absl::optional<uint64_t> fec_packets_discarded;
// Inbound FEC SSRC. Only present if a mechanism like FlexFEC is negotiated. // Inbound FEC SSRC. Only present if a mechanism like FlexFEC is negotiated.
RTCStatsMember<uint32_t> fec_ssrc; absl::optional<uint32_t> fec_ssrc;
RTCStatsMember<uint64_t> bytes_received; absl::optional<uint64_t> bytes_received;
RTCStatsMember<uint64_t> header_bytes_received; absl::optional<uint64_t> header_bytes_received;
// Inbound RTX stats. Only defined when RTX is used and it is therefore // Inbound RTX stats. Only defined when RTX is used and it is therefore
// possible to distinguish retransmissions. // possible to distinguish retransmissions.
RTCStatsMember<uint64_t> retransmitted_packets_received; absl::optional<uint64_t> retransmitted_packets_received;
RTCStatsMember<uint64_t> retransmitted_bytes_received; absl::optional<uint64_t> retransmitted_bytes_received;
RTCStatsMember<uint32_t> rtx_ssrc; absl::optional<uint32_t> rtx_ssrc;
RTCStatsMember<double> last_packet_received_timestamp; absl::optional<double> last_packet_received_timestamp;
RTCStatsMember<double> jitter_buffer_delay; absl::optional<double> jitter_buffer_delay;
RTCStatsMember<double> jitter_buffer_target_delay; absl::optional<double> jitter_buffer_target_delay;
RTCStatsMember<double> jitter_buffer_minimum_delay; absl::optional<double> jitter_buffer_minimum_delay;
RTCStatsMember<uint64_t> jitter_buffer_emitted_count; absl::optional<uint64_t> jitter_buffer_emitted_count;
RTCStatsMember<uint64_t> total_samples_received; absl::optional<uint64_t> total_samples_received;
RTCStatsMember<uint64_t> concealed_samples; absl::optional<uint64_t> concealed_samples;
RTCStatsMember<uint64_t> silent_concealed_samples; absl::optional<uint64_t> silent_concealed_samples;
RTCStatsMember<uint64_t> concealment_events; absl::optional<uint64_t> concealment_events;
RTCStatsMember<uint64_t> inserted_samples_for_deceleration; absl::optional<uint64_t> inserted_samples_for_deceleration;
RTCStatsMember<uint64_t> removed_samples_for_acceleration; absl::optional<uint64_t> removed_samples_for_acceleration;
RTCStatsMember<double> audio_level; absl::optional<double> audio_level;
RTCStatsMember<double> total_audio_energy; absl::optional<double> total_audio_energy;
RTCStatsMember<double> total_samples_duration; absl::optional<double> total_samples_duration;
// Stats below are only implemented or defined for video. // Stats below are only implemented or defined for video.
RTCStatsMember<uint32_t> frames_received; absl::optional<uint32_t> frames_received;
RTCStatsMember<uint32_t> frame_width; absl::optional<uint32_t> frame_width;
RTCStatsMember<uint32_t> frame_height; absl::optional<uint32_t> frame_height;
RTCStatsMember<double> frames_per_second; absl::optional<double> frames_per_second;
RTCStatsMember<uint32_t> frames_decoded; absl::optional<uint32_t> frames_decoded;
RTCStatsMember<uint32_t> key_frames_decoded; absl::optional<uint32_t> key_frames_decoded;
RTCStatsMember<uint32_t> frames_dropped; absl::optional<uint32_t> frames_dropped;
RTCStatsMember<double> total_decode_time; absl::optional<double> total_decode_time;
RTCStatsMember<double> total_processing_delay; absl::optional<double> total_processing_delay;
RTCStatsMember<double> total_assembly_time; absl::optional<double> total_assembly_time;
RTCStatsMember<uint32_t> frames_assembled_from_multiple_packets; absl::optional<uint32_t> frames_assembled_from_multiple_packets;
// TODO(https://crbug.com/webrtc/15600): Implement framesRendered, which is // TODO(https://crbug.com/webrtc/15600): Implement framesRendered, which is
// incremented at the same time that totalInterFrameDelay and // incremented at the same time that totalInterFrameDelay and
// totalSquaredInterFrameDelay is incremented. (Dividing inter-frame delay by // totalSquaredInterFrameDelay is incremented. (Dividing inter-frame delay by
@ -277,43 +278,43 @@ class RTC_EXPORT RTCInboundRtpStreamStats final
// at delivery to sink, not at actual render time. When we have an actual // at delivery to sink, not at actual render time. When we have an actual
// frame rendered callback, move the calculating of these metrics to there in // frame rendered callback, move the calculating of these metrics to there in
// order to make them more accurate. // order to make them more accurate.
RTCStatsMember<double> total_inter_frame_delay; absl::optional<double> total_inter_frame_delay;
RTCStatsMember<double> total_squared_inter_frame_delay; absl::optional<double> total_squared_inter_frame_delay;
RTCStatsMember<uint32_t> pause_count; absl::optional<uint32_t> pause_count;
RTCStatsMember<double> total_pauses_duration; absl::optional<double> total_pauses_duration;
RTCStatsMember<uint32_t> freeze_count; absl::optional<uint32_t> freeze_count;
RTCStatsMember<double> total_freezes_duration; absl::optional<double> total_freezes_duration;
// https://w3c.github.io/webrtc-provisional-stats/#dom-rtcinboundrtpstreamstats-contenttype // https://w3c.github.io/webrtc-provisional-stats/#dom-rtcinboundrtpstreamstats-contenttype
RTCStatsMember<std::string> content_type; absl::optional<std::string> content_type;
// Only populated if audio/video sync is enabled. // Only populated if audio/video sync is enabled.
// TODO(https://crbug.com/webrtc/14177): Expose even if A/V sync is off? // TODO(https://crbug.com/webrtc/14177): Expose even if A/V sync is off?
RTCStatsMember<double> estimated_playout_timestamp; absl::optional<double> estimated_playout_timestamp;
// Only defined for video. // Only defined for video.
// In JavaScript, this is only exposed if HW exposure is allowed. // In JavaScript, this is only exposed if HW exposure is allowed.
RTCStatsMember<std::string> decoder_implementation; absl::optional<std::string> decoder_implementation;
// FIR and PLI counts are only defined for |kind == "video"|. // FIR and PLI counts are only defined for |kind == "video"|.
RTCStatsMember<uint32_t> fir_count; absl::optional<uint32_t> fir_count;
RTCStatsMember<uint32_t> pli_count; absl::optional<uint32_t> pli_count;
RTCStatsMember<uint32_t> nack_count; absl::optional<uint32_t> nack_count;
RTCStatsMember<uint64_t> qp_sum; absl::optional<uint64_t> qp_sum;
// This is a remnant of the legacy getStats() API. When the "video-timing" // This is a remnant of the legacy getStats() API. When the "video-timing"
// header extension is used, // header extension is used,
// https://webrtc.github.io/webrtc-org/experiments/rtp-hdrext/video-timing/, // https://webrtc.github.io/webrtc-org/experiments/rtp-hdrext/video-timing/,
// `googTimingFrameInfo` is exposed with the value of // `googTimingFrameInfo` is exposed with the value of
// TimingFrameInfo::ToString(). // TimingFrameInfo::ToString().
// TODO(https://crbug.com/webrtc/14586): Unship or standardize this metric. // TODO(https://crbug.com/webrtc/14586): Unship or standardize this metric.
RTCStatsMember<std::string> goog_timing_frame_info; absl::optional<std::string> goog_timing_frame_info;
// In JavaScript, this is only exposed if HW exposure is allowed. // In JavaScript, this is only exposed if HW exposure is allowed.
RTCStatsMember<bool> power_efficient_decoder; absl::optional<bool> power_efficient_decoder;
// The following metrics are NOT exposed to JavaScript. We should consider // The following metrics are NOT exposed to JavaScript. We should consider
// standardizing or removing them. // standardizing or removing them.
RTCStatsMember<uint64_t> jitter_buffer_flushes; absl::optional<uint64_t> jitter_buffer_flushes;
RTCStatsMember<uint64_t> delayed_packet_outage_samples; absl::optional<uint64_t> delayed_packet_outage_samples;
RTCStatsMember<double> relative_packet_arrival_delay; absl::optional<double> relative_packet_arrival_delay;
RTCStatsMember<uint32_t> interruption_count; absl::optional<uint32_t> interruption_count;
RTCStatsMember<double> total_interruption_duration; absl::optional<double> total_interruption_duration;
RTCStatsMember<double> min_playout_delay; absl::optional<double> min_playout_delay;
}; };
// https://w3c.github.io/webrtc-stats/#outboundrtpstats-dict* // https://w3c.github.io/webrtc-stats/#outboundrtpstats-dict*
@ -324,46 +325,46 @@ class RTC_EXPORT RTCOutboundRtpStreamStats final
RTCOutboundRtpStreamStats(std::string id, Timestamp timestamp); RTCOutboundRtpStreamStats(std::string id, Timestamp timestamp);
~RTCOutboundRtpStreamStats() override; ~RTCOutboundRtpStreamStats() override;
RTCStatsMember<std::string> media_source_id; absl::optional<std::string> media_source_id;
RTCStatsMember<std::string> remote_id; absl::optional<std::string> remote_id;
RTCStatsMember<std::string> mid; absl::optional<std::string> mid;
RTCStatsMember<std::string> rid; absl::optional<std::string> rid;
RTCStatsMember<uint64_t> retransmitted_packets_sent; absl::optional<uint64_t> retransmitted_packets_sent;
RTCStatsMember<uint64_t> header_bytes_sent; absl::optional<uint64_t> header_bytes_sent;
RTCStatsMember<uint64_t> retransmitted_bytes_sent; absl::optional<uint64_t> retransmitted_bytes_sent;
RTCStatsMember<double> target_bitrate; absl::optional<double> target_bitrate;
RTCStatsMember<uint32_t> frames_encoded; absl::optional<uint32_t> frames_encoded;
RTCStatsMember<uint32_t> key_frames_encoded; absl::optional<uint32_t> key_frames_encoded;
RTCStatsMember<double> total_encode_time; absl::optional<double> total_encode_time;
RTCStatsMember<uint64_t> total_encoded_bytes_target; absl::optional<uint64_t> total_encoded_bytes_target;
RTCStatsMember<uint32_t> frame_width; absl::optional<uint32_t> frame_width;
RTCStatsMember<uint32_t> frame_height; absl::optional<uint32_t> frame_height;
RTCStatsMember<double> frames_per_second; absl::optional<double> frames_per_second;
RTCStatsMember<uint32_t> frames_sent; absl::optional<uint32_t> frames_sent;
RTCStatsMember<uint32_t> huge_frames_sent; absl::optional<uint32_t> huge_frames_sent;
RTCStatsMember<double> total_packet_send_delay; absl::optional<double> total_packet_send_delay;
RTCStatsMember<std::string> quality_limitation_reason; absl::optional<std::string> quality_limitation_reason;
RTCStatsMember<std::map<std::string, double>> quality_limitation_durations; absl::optional<std::map<std::string, double>> quality_limitation_durations;
// https://w3c.github.io/webrtc-stats/#dom-rtcoutboundrtpstreamstats-qualitylimitationresolutionchanges // https://w3c.github.io/webrtc-stats/#dom-rtcoutboundrtpstreamstats-qualitylimitationresolutionchanges
RTCStatsMember<uint32_t> quality_limitation_resolution_changes; absl::optional<uint32_t> quality_limitation_resolution_changes;
// https://w3c.github.io/webrtc-provisional-stats/#dom-rtcoutboundrtpstreamstats-contenttype // https://w3c.github.io/webrtc-provisional-stats/#dom-rtcoutboundrtpstreamstats-contenttype
RTCStatsMember<std::string> content_type; absl::optional<std::string> content_type;
// In JavaScript, this is only exposed if HW exposure is allowed. // In JavaScript, this is only exposed if HW exposure is allowed.
// Only implemented for video. // Only implemented for video.
// TODO(https://crbug.com/webrtc/14178): Implement for audio as well. // TODO(https://crbug.com/webrtc/14178): Implement for audio as well.
RTCStatsMember<std::string> encoder_implementation; absl::optional<std::string> encoder_implementation;
// FIR and PLI counts are only defined for |kind == "video"|. // FIR and PLI counts are only defined for |kind == "video"|.
RTCStatsMember<uint32_t> fir_count; absl::optional<uint32_t> fir_count;
RTCStatsMember<uint32_t> pli_count; absl::optional<uint32_t> pli_count;
RTCStatsMember<uint32_t> nack_count; absl::optional<uint32_t> nack_count;
RTCStatsMember<uint64_t> qp_sum; absl::optional<uint64_t> qp_sum;
RTCStatsMember<bool> active; absl::optional<bool> active;
// In JavaScript, this is only exposed if HW exposure is allowed. // In JavaScript, this is only exposed if HW exposure is allowed.
RTCStatsMember<bool> power_efficient_encoder; absl::optional<bool> power_efficient_encoder;
RTCStatsMember<std::string> scalability_mode; absl::optional<std::string> scalability_mode;
// RTX ssrc. Only present if RTX is negotiated. // RTX ssrc. Only present if RTX is negotiated.
RTCStatsMember<uint32_t> rtx_ssrc; absl::optional<uint32_t> rtx_ssrc;
}; };
// https://w3c.github.io/webrtc-stats/#remoteinboundrtpstats-dict* // https://w3c.github.io/webrtc-stats/#remoteinboundrtpstats-dict*
@ -374,11 +375,11 @@ class RTC_EXPORT RTCRemoteInboundRtpStreamStats final
RTCRemoteInboundRtpStreamStats(std::string id, Timestamp timestamp); RTCRemoteInboundRtpStreamStats(std::string id, Timestamp timestamp);
~RTCRemoteInboundRtpStreamStats() override; ~RTCRemoteInboundRtpStreamStats() override;
RTCStatsMember<std::string> local_id; absl::optional<std::string> local_id;
RTCStatsMember<double> round_trip_time; absl::optional<double> round_trip_time;
RTCStatsMember<double> fraction_lost; absl::optional<double> fraction_lost;
RTCStatsMember<double> total_round_trip_time; absl::optional<double> total_round_trip_time;
RTCStatsMember<int32_t> round_trip_time_measurements; absl::optional<int32_t> round_trip_time_measurements;
}; };
// https://w3c.github.io/webrtc-stats/#remoteoutboundrtpstats-dict* // https://w3c.github.io/webrtc-stats/#remoteoutboundrtpstats-dict*
@ -389,12 +390,12 @@ class RTC_EXPORT RTCRemoteOutboundRtpStreamStats final
RTCRemoteOutboundRtpStreamStats(std::string id, Timestamp timestamp); RTCRemoteOutboundRtpStreamStats(std::string id, Timestamp timestamp);
~RTCRemoteOutboundRtpStreamStats() override; ~RTCRemoteOutboundRtpStreamStats() override;
RTCStatsMember<std::string> local_id; absl::optional<std::string> local_id;
RTCStatsMember<double> remote_timestamp; absl::optional<double> remote_timestamp;
RTCStatsMember<uint64_t> reports_sent; absl::optional<uint64_t> reports_sent;
RTCStatsMember<double> round_trip_time; absl::optional<double> round_trip_time;
RTCStatsMember<uint64_t> round_trip_time_measurements; absl::optional<uint64_t> round_trip_time_measurements;
RTCStatsMember<double> total_round_trip_time; absl::optional<double> total_round_trip_time;
}; };
// https://w3c.github.io/webrtc-stats/#dom-rtcmediasourcestats // https://w3c.github.io/webrtc-stats/#dom-rtcmediasourcestats
@ -403,8 +404,8 @@ class RTC_EXPORT RTCMediaSourceStats : public RTCStats {
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
~RTCMediaSourceStats() override; ~RTCMediaSourceStats() override;
RTCStatsMember<std::string> track_identifier; absl::optional<std::string> track_identifier;
RTCStatsMember<std::string> kind; absl::optional<std::string> kind;
protected: protected:
RTCMediaSourceStats(std::string id, Timestamp timestamp); RTCMediaSourceStats(std::string id, Timestamp timestamp);
@ -417,11 +418,11 @@ class RTC_EXPORT RTCAudioSourceStats final : public RTCMediaSourceStats {
RTCAudioSourceStats(std::string id, Timestamp timestamp); RTCAudioSourceStats(std::string id, Timestamp timestamp);
~RTCAudioSourceStats() override; ~RTCAudioSourceStats() override;
RTCStatsMember<double> audio_level; absl::optional<double> audio_level;
RTCStatsMember<double> total_audio_energy; absl::optional<double> total_audio_energy;
RTCStatsMember<double> total_samples_duration; absl::optional<double> total_samples_duration;
RTCStatsMember<double> echo_return_loss; absl::optional<double> echo_return_loss;
RTCStatsMember<double> echo_return_loss_enhancement; absl::optional<double> echo_return_loss_enhancement;
}; };
// https://w3c.github.io/webrtc-stats/#dom-rtcvideosourcestats // https://w3c.github.io/webrtc-stats/#dom-rtcvideosourcestats
@ -431,10 +432,10 @@ class RTC_EXPORT RTCVideoSourceStats final : public RTCMediaSourceStats {
RTCVideoSourceStats(std::string id, Timestamp timestamp); RTCVideoSourceStats(std::string id, Timestamp timestamp);
~RTCVideoSourceStats() override; ~RTCVideoSourceStats() override;
RTCStatsMember<uint32_t> width; absl::optional<uint32_t> width;
RTCStatsMember<uint32_t> height; absl::optional<uint32_t> height;
RTCStatsMember<uint32_t> frames; absl::optional<uint32_t> frames;
RTCStatsMember<double> frames_per_second; absl::optional<double> frames_per_second;
}; };
// https://w3c.github.io/webrtc-stats/#transportstats-dict* // https://w3c.github.io/webrtc-stats/#transportstats-dict*
@ -444,23 +445,23 @@ class RTC_EXPORT RTCTransportStats final : public RTCStats {
RTCTransportStats(std::string id, Timestamp timestamp); RTCTransportStats(std::string id, Timestamp timestamp);
~RTCTransportStats() override; ~RTCTransportStats() override;
RTCStatsMember<uint64_t> bytes_sent; absl::optional<uint64_t> bytes_sent;
RTCStatsMember<uint64_t> packets_sent; absl::optional<uint64_t> packets_sent;
RTCStatsMember<uint64_t> bytes_received; absl::optional<uint64_t> bytes_received;
RTCStatsMember<uint64_t> packets_received; absl::optional<uint64_t> packets_received;
RTCStatsMember<std::string> rtcp_transport_stats_id; absl::optional<std::string> rtcp_transport_stats_id;
RTCStatsMember<std::string> dtls_state; absl::optional<std::string> dtls_state;
RTCStatsMember<std::string> selected_candidate_pair_id; absl::optional<std::string> selected_candidate_pair_id;
RTCStatsMember<std::string> local_certificate_id; absl::optional<std::string> local_certificate_id;
RTCStatsMember<std::string> remote_certificate_id; absl::optional<std::string> remote_certificate_id;
RTCStatsMember<std::string> tls_version; absl::optional<std::string> tls_version;
RTCStatsMember<std::string> dtls_cipher; absl::optional<std::string> dtls_cipher;
RTCStatsMember<std::string> dtls_role; absl::optional<std::string> dtls_role;
RTCStatsMember<std::string> srtp_cipher; absl::optional<std::string> srtp_cipher;
RTCStatsMember<uint32_t> selected_candidate_pair_changes; absl::optional<uint32_t> selected_candidate_pair_changes;
RTCStatsMember<std::string> ice_role; absl::optional<std::string> ice_role;
RTCStatsMember<std::string> ice_local_username_fragment; absl::optional<std::string> ice_local_username_fragment;
RTCStatsMember<std::string> ice_state; absl::optional<std::string> ice_state;
}; };
// https://w3c.github.io/webrtc-stats/#playoutstats-dict* // https://w3c.github.io/webrtc-stats/#playoutstats-dict*
@ -470,12 +471,12 @@ class RTC_EXPORT RTCAudioPlayoutStats final : public RTCStats {
RTCAudioPlayoutStats(const std::string& id, Timestamp timestamp); RTCAudioPlayoutStats(const std::string& id, Timestamp timestamp);
~RTCAudioPlayoutStats() override; ~RTCAudioPlayoutStats() override;
RTCStatsMember<std::string> kind; absl::optional<std::string> kind;
RTCStatsMember<double> synthesized_samples_duration; absl::optional<double> synthesized_samples_duration;
RTCStatsMember<uint64_t> synthesized_samples_events; absl::optional<uint64_t> synthesized_samples_events;
RTCStatsMember<double> total_samples_duration; absl::optional<double> total_samples_duration;
RTCStatsMember<double> total_playout_delay; absl::optional<double> total_playout_delay;
RTCStatsMember<uint64_t> total_samples_count; absl::optional<uint64_t> total_samples_count;
}; };
} // namespace webrtc } // namespace webrtc

1
pc/BUILD.gn
View file

@ -970,6 +970,7 @@ rtc_source_set("rtc_stats_traversal") {
"../api:scoped_refptr", "../api:scoped_refptr",
"../rtc_base:checks", "../rtc_base:checks",
] ]
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
} }
rtc_source_set("sdp_offer_answer") { rtc_source_set("sdp_offer_answer") {

3
pc/rtc_stats_collector_unittest.cc
View file

@ -23,6 +23,7 @@
#include <vector> #include <vector>
#include "absl/strings/str_replace.h" #include "absl/strings/str_replace.h"
#include "absl/types/optional.h"
#include "api/candidate.h" #include "api/candidate.h"
#include "api/dtls_transport_interface.h" #include "api/dtls_transport_interface.h"
#include "api/media_stream_interface.h" #include "api/media_stream_interface.h"
@ -3723,7 +3724,7 @@ class RTCTestStats : public RTCStats {
RTCTestStats(const std::string& id, Timestamp timestamp) RTCTestStats(const std::string& id, Timestamp timestamp)
: RTCStats(id, timestamp) {} : RTCStats(id, timestamp) {}
RTCStatsMember<int32_t> dummy_stat; absl::optional<int32_t> dummy_stat;
}; };
WEBRTC_RTCSTATS_IMPL(RTCTestStats, WEBRTC_RTCSTATS_IMPL(RTCTestStats,

17
pc/rtc_stats_integrationtest.cc
View file

@ -18,6 +18,7 @@
#include "absl/algorithm/container.h" #include "absl/algorithm/container.h"
#include "absl/strings/match.h" #include "absl/strings/match.h"
#include "absl/types/optional.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h" #include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h" #include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/audio_options.h" #include "api/audio_options.h"
@ -212,14 +213,14 @@ class RTCStatsVerifier {
} }
template <typename T> template <typename T>
void MarkAttributeTested(const RTCStatsMember<T>& field, void MarkAttributeTested(const absl::optional<T>& field,
bool test_successful) { bool test_successful) {
untested_attribute_names_.erase(stats_->GetAttribute(field).name()); untested_attribute_names_.erase(stats_->GetAttribute(field).name());
all_tests_successful_ &= test_successful; all_tests_successful_ &= test_successful;
} }
template <typename T> template <typename T>
void TestAttributeIsDefined(const RTCStatsMember<T>& field) { void TestAttributeIsDefined(const absl::optional<T>& field) {
EXPECT_TRUE(field.has_value()) EXPECT_TRUE(field.has_value())
<< stats_->type() << "." << stats_->GetAttribute(field).name() << "[" << stats_->type() << "." << stats_->GetAttribute(field).name() << "["
<< stats_->id() << "] was undefined."; << stats_->id() << "] was undefined.";
@ -227,7 +228,7 @@ class RTCStatsVerifier {
} }
template <typename T> template <typename T>
void TestAttributeIsUndefined(const RTCStatsMember<T>& field) { void TestAttributeIsUndefined(const absl::optional<T>& field) {
Attribute attribute = stats_->GetAttribute(field); Attribute attribute = stats_->GetAttribute(field);
EXPECT_FALSE(field.has_value()) EXPECT_FALSE(field.has_value())
<< stats_->type() << "." << attribute.name() << "[" << stats_->id() << stats_->type() << "." << attribute.name() << "[" << stats_->id()
@ -236,7 +237,7 @@ class RTCStatsVerifier {
} }
template <typename T> template <typename T>
void TestAttributeIsPositive(const RTCStatsMember<T>& field) { void TestAttributeIsPositive(const absl::optional<T>& field) {
Attribute attribute = stats_->GetAttribute(field); Attribute attribute = stats_->GetAttribute(field);
EXPECT_TRUE(field.has_value()) << stats_->type() << "." << attribute.name() EXPECT_TRUE(field.has_value()) << stats_->type() << "." << attribute.name()
<< "[" << stats_->id() << "] was undefined."; << "[" << stats_->id() << "] was undefined.";
@ -252,7 +253,7 @@ class RTCStatsVerifier {
} }
template <typename T> template <typename T>
void TestAttributeIsNonNegative(const RTCStatsMember<T>& field) { void TestAttributeIsNonNegative(const absl::optional<T>& field) {
Attribute attribute = stats_->GetAttribute(field); Attribute attribute = stats_->GetAttribute(field);
EXPECT_TRUE(field.has_value()) << stats_->type() << "." << attribute.name() EXPECT_TRUE(field.has_value()) << stats_->type() << "." << attribute.name()
<< "[" << stats_->id() << "] was undefined."; << "[" << stats_->id() << "] was undefined.";
@ -268,13 +269,13 @@ class RTCStatsVerifier {
} }
template <typename T> template <typename T>
void TestAttributeIsIDReference(const RTCStatsMember<T>& field, void TestAttributeIsIDReference(const absl::optional<T>& field,
const char* expected_type) { const char* expected_type) {
TestAttributeIsIDReference(field, expected_type, false); TestAttributeIsIDReference(field, expected_type, false);
} }
template <typename T> template <typename T>
void TestAttributeIsOptionalIDReference(const RTCStatsMember<T>& field, void TestAttributeIsOptionalIDReference(const absl::optional<T>& field,
const char* expected_type) { const char* expected_type) {
TestAttributeIsIDReference(field, expected_type, true); TestAttributeIsIDReference(field, expected_type, true);
} }
@ -291,7 +292,7 @@ class RTCStatsVerifier {
private: private:
template <typename T> template <typename T>
void TestAttributeIsIDReference(const RTCStatsMember<T>& field, void TestAttributeIsIDReference(const absl::optional<T>& field,
const char* expected_type, const char* expected_type,
bool optional) { bool optional) {
if (optional && !field.has_value()) { if (optional && !field.has_value()) {

3
pc/rtc_stats_traversal.cc
View file

@ -15,6 +15,7 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "absl/types/optional.h"
#include "api/stats/rtcstats_objects.h" #include "api/stats/rtcstats_objects.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
@ -42,7 +43,7 @@ void TraverseAndTakeVisitedStats(RTCStatsReport* report,
} }
} }
void AddIdIfDefined(const RTCStatsMember<std::string>& id, void AddIdIfDefined(const absl::optional<std::string>& id,
std::vector<const std::string*>* neighbor_ids) { std::vector<const std::string*>* neighbor_ids) {
if (id.has_value()) if (id.has_value())
neighbor_ids->push_back(&(*id)); neighbor_ids->push_back(&(*id));

3
stats/BUILD.gn
View file

@ -45,6 +45,7 @@ rtc_library("rtc_stats_test_utils") {
"../rtc_base:checks", "../rtc_base:checks",
"../rtc_base/system:rtc_export", "../rtc_base/system:rtc_export",
] ]
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
} }
if (rtc_include_tests && !build_with_chromium) { if (rtc_include_tests && !build_with_chromium) {
@ -74,5 +75,7 @@ if (rtc_include_tests && !build_with_chromium) {
"//testing/android/native_test:native_test_support", "//testing/android/native_test:native_test_support",
] ]
} }
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
} }
} }

7
stats/rtc_stats_report_unittest.cc
View file

@ -10,6 +10,7 @@
#include "api/stats/rtc_stats_report.h" #include "api/stats/rtc_stats_report.h"
#include "absl/types/optional.h"
#include "api/stats/attribute.h" #include "api/stats/attribute.h"
#include "api/stats/rtc_stats.h" #include "api/stats/rtc_stats.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
@ -24,7 +25,7 @@ class RTCTestStats1 : public RTCStats {
RTCTestStats1(const std::string& id, Timestamp timestamp) RTCTestStats1(const std::string& id, Timestamp timestamp)
: RTCStats(id, timestamp) {} : RTCStats(id, timestamp) {}
RTCStatsMember<int32_t> integer; absl::optional<int32_t> integer;
}; };
WEBRTC_RTCSTATS_IMPL(RTCTestStats1, WEBRTC_RTCSTATS_IMPL(RTCTestStats1,
@ -39,7 +40,7 @@ class RTCTestStats2 : public RTCStats {
RTCTestStats2(const std::string& id, Timestamp timestamp) RTCTestStats2(const std::string& id, Timestamp timestamp)
: RTCStats(id, timestamp) {} : RTCStats(id, timestamp) {}
RTCStatsMember<double> number; absl::optional<double> number;
}; };
WEBRTC_RTCSTATS_IMPL(RTCTestStats2, WEBRTC_RTCSTATS_IMPL(RTCTestStats2,
@ -54,7 +55,7 @@ class RTCTestStats3 : public RTCStats {
RTCTestStats3(const std::string& id, Timestamp timestamp) RTCTestStats3(const std::string& id, Timestamp timestamp)
: RTCStats(id, timestamp) {} : RTCStats(id, timestamp) {}
RTCStatsMember<std::string> string; absl::optional<std::string> string;
}; };
WEBRTC_RTCSTATS_IMPL(RTCTestStats3, WEBRTC_RTCSTATS_IMPL(RTCTestStats3,

5
stats/rtc_stats_unittest.cc
View file

@ -15,6 +15,7 @@
#include <cstring> #include <cstring>
#include <iostream> #include <iostream>
#include "absl/types/optional.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/strings/json.h" #include "rtc_base/strings/json.h"
#include "stats/test/rtc_test_stats.h" #include "stats/test/rtc_test_stats.h"
@ -46,7 +47,7 @@ class RTCChildStats : public RTCStats {
RTCChildStats(const std::string& id, Timestamp timestamp) RTCChildStats(const std::string& id, Timestamp timestamp)
: RTCStats(id, timestamp) {} : RTCStats(id, timestamp) {}
RTCStatsMember<int32_t> child_int; absl::optional<int32_t> child_int;
}; };
WEBRTC_RTCSTATS_IMPL(RTCChildStats, WEBRTC_RTCSTATS_IMPL(RTCChildStats,
@ -61,7 +62,7 @@ class RTCGrandChildStats : public RTCChildStats {
RTCGrandChildStats(const std::string& id, Timestamp timestamp) RTCGrandChildStats(const std::string& id, Timestamp timestamp)
: RTCChildStats(id, timestamp) {} : RTCChildStats(id, timestamp) {}
RTCStatsMember<int32_t> grandchild_int; absl::optional<int32_t> grandchild_int;
}; };
WEBRTC_RTCSTATS_IMPL(RTCGrandChildStats, WEBRTC_RTCSTATS_IMPL(RTCGrandChildStats,

33
stats/test/rtc_test_stats.h
View file

@ -16,6 +16,7 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "absl/types/optional.h"
#include "api/stats/rtc_stats.h" #include "api/stats/rtc_stats.h"
#include "rtc_base/system/rtc_export.h" #include "rtc_base/system/rtc_export.h"
@ -27,22 +28,22 @@ class RTC_EXPORT RTCTestStats : public RTCStats {
RTCTestStats(const std::string& id, Timestamp timestamp); RTCTestStats(const std::string& id, Timestamp timestamp);
~RTCTestStats() override; ~RTCTestStats() override;
RTCStatsMember<bool> m_bool; absl::optional<bool> m_bool;
RTCStatsMember<int32_t> m_int32; absl::optional<int32_t> m_int32;
RTCStatsMember<uint32_t> m_uint32; absl::optional<uint32_t> m_uint32;
RTCStatsMember<int64_t> m_int64; absl::optional<int64_t> m_int64;
RTCStatsMember<uint64_t> m_uint64; absl::optional<uint64_t> m_uint64;
RTCStatsMember<double> m_double; absl::optional<double> m_double;
RTCStatsMember<std::string> m_string; absl::optional<std::string> m_string;
RTCStatsMember<std::vector<bool>> m_sequence_bool; absl::optional<std::vector<bool>> m_sequence_bool;
RTCStatsMember<std::vector<int32_t>> m_sequence_int32; absl::optional<std::vector<int32_t>> m_sequence_int32;
RTCStatsMember<std::vector<uint32_t>> m_sequence_uint32; absl::optional<std::vector<uint32_t>> m_sequence_uint32;
RTCStatsMember<std::vector<int64_t>> m_sequence_int64; absl::optional<std::vector<int64_t>> m_sequence_int64;
RTCStatsMember<std::vector<uint64_t>> m_sequence_uint64; absl::optional<std::vector<uint64_t>> m_sequence_uint64;
RTCStatsMember<std::vector<double>> m_sequence_double; absl::optional<std::vector<double>> m_sequence_double;
RTCStatsMember<std::vector<std::string>> m_sequence_string; absl::optional<std::vector<std::string>> m_sequence_string;
RTCStatsMember<std::map<std::string, uint64_t>> m_map_string_uint64; absl::optional<std::map<std::string, uint64_t>> m_map_string_uint64;
RTCStatsMember<std::map<std::string, double>> m_map_string_double; absl::optional<std::map<std::string, double>> m_map_string_double;
}; };
} // namespace webrtc } // namespace webrtc