admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "[Stats] Move metric names to Attribute, constructed via AttributeInit."

Browse Source 
This reverts commit 84c48ae7513bad9c9ca19271569cd0431e780c32.

Reason for revert: Breaks downstream project

Original change's description:
> [Stats] Move metric names to Attribute, constructed via AttributeInit.
>
> As of this CL, Attribute no longer implements RTCStatsMemberInterface
> and a member no longer owns knowing its own name. The attribute knows
> the name because we pass it down at construction time.
>
> To achieve this, the WEBRTC_RTCSTATS_IMPL() macro is updated to take
> AttributeInits instead of raw member pointers, i.e. (name, ptr) pairs.
>
> By constructing RTCStatsMember<T> without a name parameter, it does the
> same thing as the absl::optional<T> constructor. So RTCStatsMember<T>'s
> days are numbered!
>
> Bug: webrtc:15164
> Change-Id: I560c0134bae1c2d7218426a1576425ecc1b677a7
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/334203
> Commit-Queue: Henrik Boström <hbos@webrtc.org>
> Reviewed-by: Evan Shrubsole <eshr@google.com>
> Cr-Commit-Position: refs/heads/main@{#41540}

Bug: webrtc:15164
Change-Id: I9f416838153b26d4560ae98c37fb18a803d0295d
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/334901
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Bot-Commit: rubber-stamper@appspot.gserviceaccount.com <rubber-stamper@appspot.gserviceaccount.com>
Owners-Override: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41550}
This commit is contained in:
Mirko Bonadei 2024-01-17 16:59:52 +00:00 committed by WebRTC LUCI CQ
parent 361d74bc36
commit df3b3bd06f
11 changed files with 718 additions and 356 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
api/stats/attribute.h
View File

@ -23,7 +23,7 @@
namespace webrtc { namespace webrtc {
// A light-weight wrapper of an RTCStats attribute (an individual metric). // A light-weight wrapper of an RTCStats attribute (an individual metric).
class RTC_EXPORT Attribute { class RTC_EXPORT Attribute : public RTCStatsMemberInterface {
public: public:
// TODO(https://crbug.com/webrtc/15164): Replace uses of RTCStatsMember<T> // TODO(https://crbug.com/webrtc/15164): Replace uses of RTCStatsMember<T>
// with absl::optional<T> and update these pointer types. // with absl::optional<T> and update these pointer types.
@ -46,8 +46,9 @@ class RTC_EXPORT Attribute {
StatVariant; StatVariant;
template <typename T> template <typename T>
explicit Attribute(const char* name, const RTCStatsMember<T>* attribute) explicit Attribute(const RTCStatsMember<T>* attribute)
: name_(name), attribute_(attribute) {} : RTCStatsMemberInterface(attribute->name()), attribute_(attribute) {}
~Attribute() override;
const char* name() const; const char* name() const;
const StatVariant& as_variant() const; const StatVariant& as_variant() const;
@ -58,39 +59,32 @@ class RTC_EXPORT Attribute {
return absl::holds_alternative<const RTCStatsMember<T>*>(attribute_); return absl::holds_alternative<const RTCStatsMember<T>*>(attribute_);
} }
template <typename T> template <typename T>
absl::optional<T> as_optional() const {
RTC_CHECK(holds_alternative<T>());
if (!has_value()) {
return absl::nullopt;
}
return absl::optional<T>(get<T>());
}
template <typename T>
const T& get() const { const T& get() const {
RTC_CHECK(holds_alternative<T>()); RTC_CHECK(holds_alternative<T>());
RTC_CHECK(has_value()); RTC_CHECK(has_value());
return absl::get<const RTCStatsMember<T>*>(attribute_)->value(); return absl::get<const RTCStatsMember<T>*>(attribute_)->value();
} }
bool is_sequence() const; static Attribute FromMemberInterface(const RTCStatsMemberInterface* member);
bool is_string() const; // RTCStatsMemberInterface implementation.
std::string ValueToString() const; // TODO(https://crbug.com/webrtc/15164): Delete RTCStatsMemberInterface in
std::string ValueToJson() const; // favor of absl::optional<T>.
RTCStatsMemberInterface::Type type() const override;
bool is_sequence() const override;
bool is_string() const override;
bool is_defined() const override;
std::string ValueToString() const override;
std::string ValueToJson() const override;
bool operator==(const Attribute& other) const; protected:
bool operator!=(const Attribute& other) const; const RTCStatsMemberInterface* member_ptr() const override;
bool IsEqual(const RTCStatsMemberInterface& other) const override;
private: private:
const char* name_;
StatVariant attribute_; StatVariant attribute_;
}; };
struct RTC_EXPORT AttributeInit { Attribute MemberToAttribute(const RTCStatsMemberInterface* member);
AttributeInit(const char* name, const Attribute::StatVariant& variant);
const char* name;
Attribute::StatVariant variant;
};
} // namespace webrtc } // namespace webrtc

48
api/stats/rtc_stats.h
View File

@ -162,32 +162,28 @@ class RTC_EXPORT RTCStats {
std::unique_ptr<webrtc::RTCStats> copy() const override; \ std::unique_ptr<webrtc::RTCStats> copy() const override; \
const char* type() const override const char* type() const override
#define WEBRTC_RTCSTATS_IMPL(this_class, parent_class, type_str, ...) \ #define WEBRTC_RTCSTATS_IMPL(this_class, parent_class, type_str, ...) \
const char this_class::kType[] = type_str; \ const char this_class::kType[] = type_str; \
\ \
std::unique_ptr<webrtc::RTCStats> this_class::copy() const { \ std::unique_ptr<webrtc::RTCStats> this_class::copy() const { \
return std::make_unique<this_class>(*this); \ return std::make_unique<this_class>(*this); \
} \ } \
\ \
const char* this_class::type() const { \ const char* this_class::type() const { \
return this_class::kType; \ return this_class::kType; \
} \ } \
\ \
std::vector<webrtc::Attribute> this_class::AttributesImpl( \ std::vector<webrtc::Attribute> this_class::AttributesImpl( \
size_t additional_capacity) const { \ size_t additional_capacity) const { \
webrtc::AttributeInit attribute_inits[] = {__VA_ARGS__}; \ const webrtc::RTCStatsMemberInterface* this_members[] = {__VA_ARGS__}; \
size_t attribute_inits_size = \ size_t this_members_size = sizeof(this_members) / sizeof(this_members[0]); \
sizeof(attribute_inits) / sizeof(attribute_inits[0]); \ std::vector<webrtc::Attribute> attributes = \
std::vector<webrtc::Attribute> attributes = parent_class::AttributesImpl( \ parent_class::AttributesImpl(this_members_size + additional_capacity); \
attribute_inits_size + additional_capacity); \ for (size_t i = 0; i < this_members_size; ++i) { \
for (size_t i = 0; i < attribute_inits_size; ++i) { \ attributes.push_back( \
attributes.push_back(absl::visit( \ webrtc::Attribute::FromMemberInterface(this_members[i])); \
[&](const auto* field) { \ } \
return Attribute(attribute_inits[i].name, field); \ return attributes; \
}, \
attribute_inits[i].variant)); \
} \
return attributes; \
} }
} // namespace webrtc } // namespace webrtc

17
api/stats/rtc_stats_member.h
View File

@ -53,6 +53,7 @@ class RTCStatsMemberInterface {
virtual ~RTCStatsMemberInterface() {} virtual ~RTCStatsMemberInterface() {}
const char* name() const { return name_; }
virtual Type type() const = 0; virtual Type type() const = 0;
virtual bool is_sequence() const = 0; virtual bool is_sequence() const = 0;
virtual bool is_string() const = 0; virtual bool is_string() const = 0;
@ -81,7 +82,11 @@ class RTCStatsMemberInterface {
} }
protected: protected:
explicit RTCStatsMemberInterface(const char* name) : name_(name) {}
virtual bool IsEqual(const RTCStatsMemberInterface& other) const = 0; virtual bool IsEqual(const RTCStatsMemberInterface& other) const = 0;
const char* const name_;
}; };
// Template implementation of `RTCStatsMemberInterface`. // Template implementation of `RTCStatsMemberInterface`.
@ -90,8 +95,16 @@ class RTCStatsMemberInterface {
template <typename T> template <typename T>
class RTCStatsMember : public RTCStatsMemberInterface { class RTCStatsMember : public RTCStatsMemberInterface {
public: public:
RTCStatsMember() {} explicit RTCStatsMember(const char* name)
explicit RTCStatsMember(const T& value) : value_(value) {} : RTCStatsMemberInterface(name), value_() {}
RTCStatsMember(const char* name, const T& value)
: RTCStatsMemberInterface(name), value_(value) {}
RTCStatsMember(const char* name, T&& value)
: RTCStatsMemberInterface(name), value_(std::move(value)) {}
explicit RTCStatsMember(const RTCStatsMember<T>& other)
: RTCStatsMemberInterface(other.name_), value_(other.value_) {}
explicit RTCStatsMember(RTCStatsMember<T>&& other)
: RTCStatsMemberInterface(other.name_), value_(std::move(other.value_)) {}
static Type StaticType(); static Type StaticType();
Type type() const override { return StaticType(); } Type type() const override { return StaticType(); }

36
api/stats/rtcstats_objects.h
View File

@ -27,7 +27,9 @@ namespace webrtc {
class RTC_EXPORT RTCCertificateStats final : public RTCStats { class RTC_EXPORT RTCCertificateStats final : public RTCStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCCertificateStats(std::string id, Timestamp timestamp); RTCCertificateStats(std::string id, Timestamp timestamp);
RTCCertificateStats(const RTCCertificateStats& other);
~RTCCertificateStats() override; ~RTCCertificateStats() override;
RTCStatsMember<std::string> fingerprint; RTCStatsMember<std::string> fingerprint;
@ -40,7 +42,9 @@ class RTC_EXPORT RTCCertificateStats final : public RTCStats {
class RTC_EXPORT RTCCodecStats final : public RTCStats { class RTC_EXPORT RTCCodecStats final : public RTCStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCCodecStats(std::string id, Timestamp timestamp); RTCCodecStats(std::string id, Timestamp timestamp);
RTCCodecStats(const RTCCodecStats& other);
~RTCCodecStats() override; ~RTCCodecStats() override;
RTCStatsMember<std::string> transport_id; RTCStatsMember<std::string> transport_id;
@ -55,7 +59,9 @@ class RTC_EXPORT RTCCodecStats final : public RTCStats {
class RTC_EXPORT RTCDataChannelStats final : public RTCStats { class RTC_EXPORT RTCDataChannelStats final : public RTCStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCDataChannelStats(std::string id, Timestamp timestamp); RTCDataChannelStats(std::string id, Timestamp timestamp);
RTCDataChannelStats(const RTCDataChannelStats& other);
~RTCDataChannelStats() override; ~RTCDataChannelStats() override;
RTCStatsMember<std::string> label; RTCStatsMember<std::string> label;
@ -72,7 +78,9 @@ class RTC_EXPORT RTCDataChannelStats final : public RTCStats {
class RTC_EXPORT RTCIceCandidatePairStats final : public RTCStats { class RTC_EXPORT RTCIceCandidatePairStats final : public RTCStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCIceCandidatePairStats(std::string id, Timestamp timestamp); RTCIceCandidatePairStats(std::string id, Timestamp timestamp);
RTCIceCandidatePairStats(const RTCIceCandidatePairStats& other);
~RTCIceCandidatePairStats() override; ~RTCIceCandidatePairStats() override;
RTCStatsMember<std::string> transport_id; RTCStatsMember<std::string> transport_id;
@ -110,6 +118,8 @@ class RTC_EXPORT RTCIceCandidatePairStats final : public RTCStats {
class RTC_EXPORT RTCIceCandidateStats : public RTCStats { class RTC_EXPORT RTCIceCandidateStats : public RTCStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCIceCandidateStats(const RTCIceCandidateStats& other);
~RTCIceCandidateStats() override; ~RTCIceCandidateStats() override;
RTCStatsMember<std::string> transport_id; RTCStatsMember<std::string> transport_id;
@ -165,7 +175,9 @@ class RTC_EXPORT RTCRemoteIceCandidateStats final
class RTC_EXPORT RTCPeerConnectionStats final : public RTCStats { class RTC_EXPORT RTCPeerConnectionStats final : public RTCStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCPeerConnectionStats(std::string id, Timestamp timestamp); RTCPeerConnectionStats(std::string id, Timestamp timestamp);
RTCPeerConnectionStats(const RTCPeerConnectionStats& other);
~RTCPeerConnectionStats() override; ~RTCPeerConnectionStats() override;
RTCStatsMember<uint32_t> data_channels_opened; RTCStatsMember<uint32_t> data_channels_opened;
@ -176,6 +188,8 @@ class RTC_EXPORT RTCPeerConnectionStats final : public RTCStats {
class RTC_EXPORT RTCRtpStreamStats : public RTCStats { class RTC_EXPORT RTCRtpStreamStats : public RTCStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCRtpStreamStats(const RTCRtpStreamStats& other);
~RTCRtpStreamStats() override; ~RTCRtpStreamStats() override;
RTCStatsMember<uint32_t> ssrc; RTCStatsMember<uint32_t> ssrc;
@ -191,6 +205,8 @@ class RTC_EXPORT RTCRtpStreamStats : public RTCStats {
class RTC_EXPORT RTCReceivedRtpStreamStats : public RTCRtpStreamStats { class RTC_EXPORT RTCReceivedRtpStreamStats : public RTCRtpStreamStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCReceivedRtpStreamStats(const RTCReceivedRtpStreamStats& other);
~RTCReceivedRtpStreamStats() override; ~RTCReceivedRtpStreamStats() override;
RTCStatsMember<double> jitter; RTCStatsMember<double> jitter;
@ -204,6 +220,8 @@ class RTC_EXPORT RTCReceivedRtpStreamStats : public RTCRtpStreamStats {
class RTC_EXPORT RTCSentRtpStreamStats : public RTCRtpStreamStats { class RTC_EXPORT RTCSentRtpStreamStats : public RTCRtpStreamStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCSentRtpStreamStats(const RTCSentRtpStreamStats& other);
~RTCSentRtpStreamStats() override; ~RTCSentRtpStreamStats() override;
RTCStatsMember<uint64_t> packets_sent; RTCStatsMember<uint64_t> packets_sent;
@ -218,7 +236,9 @@ class RTC_EXPORT RTCInboundRtpStreamStats final
: public RTCReceivedRtpStreamStats { : public RTCReceivedRtpStreamStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCInboundRtpStreamStats(std::string id, Timestamp timestamp); RTCInboundRtpStreamStats(std::string id, Timestamp timestamp);
RTCInboundRtpStreamStats(const RTCInboundRtpStreamStats& other);
~RTCInboundRtpStreamStats() override; ~RTCInboundRtpStreamStats() override;
RTCStatsMember<std::string> playout_id; RTCStatsMember<std::string> playout_id;
@ -321,7 +341,9 @@ class RTC_EXPORT RTCOutboundRtpStreamStats final
: public RTCSentRtpStreamStats { : public RTCSentRtpStreamStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCOutboundRtpStreamStats(std::string id, Timestamp timestamp); RTCOutboundRtpStreamStats(std::string id, Timestamp timestamp);
RTCOutboundRtpStreamStats(const RTCOutboundRtpStreamStats& other);
~RTCOutboundRtpStreamStats() override; ~RTCOutboundRtpStreamStats() override;
RTCStatsMember<std::string> media_source_id; RTCStatsMember<std::string> media_source_id;
@ -371,7 +393,9 @@ class RTC_EXPORT RTCRemoteInboundRtpStreamStats final
: public RTCReceivedRtpStreamStats { : public RTCReceivedRtpStreamStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCRemoteInboundRtpStreamStats(std::string id, Timestamp timestamp); RTCRemoteInboundRtpStreamStats(std::string id, Timestamp timestamp);
RTCRemoteInboundRtpStreamStats(const RTCRemoteInboundRtpStreamStats& other);
~RTCRemoteInboundRtpStreamStats() override; ~RTCRemoteInboundRtpStreamStats() override;
RTCStatsMember<std::string> local_id; RTCStatsMember<std::string> local_id;
@ -386,7 +410,9 @@ class RTC_EXPORT RTCRemoteOutboundRtpStreamStats final
: public RTCSentRtpStreamStats { : public RTCSentRtpStreamStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCRemoteOutboundRtpStreamStats(std::string id, Timestamp timestamp); RTCRemoteOutboundRtpStreamStats(std::string id, Timestamp timestamp);
RTCRemoteOutboundRtpStreamStats(const RTCRemoteOutboundRtpStreamStats& other);
~RTCRemoteOutboundRtpStreamStats() override; ~RTCRemoteOutboundRtpStreamStats() override;
RTCStatsMember<std::string> local_id; RTCStatsMember<std::string> local_id;
@ -401,6 +427,8 @@ class RTC_EXPORT RTCRemoteOutboundRtpStreamStats final
class RTC_EXPORT RTCMediaSourceStats : public RTCStats { class RTC_EXPORT RTCMediaSourceStats : public RTCStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCMediaSourceStats(const RTCMediaSourceStats& other);
~RTCMediaSourceStats() override; ~RTCMediaSourceStats() override;
RTCStatsMember<std::string> track_identifier; RTCStatsMember<std::string> track_identifier;
@ -414,7 +442,9 @@ class RTC_EXPORT RTCMediaSourceStats : public RTCStats {
class RTC_EXPORT RTCAudioSourceStats final : public RTCMediaSourceStats { class RTC_EXPORT RTCAudioSourceStats final : public RTCMediaSourceStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCAudioSourceStats(std::string id, Timestamp timestamp); RTCAudioSourceStats(std::string id, Timestamp timestamp);
RTCAudioSourceStats(const RTCAudioSourceStats& other);
~RTCAudioSourceStats() override; ~RTCAudioSourceStats() override;
RTCStatsMember<double> audio_level; RTCStatsMember<double> audio_level;
@ -428,7 +458,9 @@ class RTC_EXPORT RTCAudioSourceStats final : public RTCMediaSourceStats {
class RTC_EXPORT RTCVideoSourceStats final : public RTCMediaSourceStats { class RTC_EXPORT RTCVideoSourceStats final : public RTCMediaSourceStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCVideoSourceStats(std::string id, Timestamp timestamp); RTCVideoSourceStats(std::string id, Timestamp timestamp);
RTCVideoSourceStats(const RTCVideoSourceStats& other);
~RTCVideoSourceStats() override; ~RTCVideoSourceStats() override;
RTCStatsMember<uint32_t> width; RTCStatsMember<uint32_t> width;
@ -441,7 +473,9 @@ class RTC_EXPORT RTCVideoSourceStats final : public RTCMediaSourceStats {
class RTC_EXPORT RTCTransportStats final : public RTCStats { class RTC_EXPORT RTCTransportStats final : public RTCStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCTransportStats(std::string id, Timestamp timestamp); RTCTransportStats(std::string id, Timestamp timestamp);
RTCTransportStats(const RTCTransportStats& other);
~RTCTransportStats() override; ~RTCTransportStats() override;
RTCStatsMember<uint64_t> bytes_sent; RTCStatsMember<uint64_t> bytes_sent;
@ -467,7 +501,9 @@ class RTC_EXPORT RTCTransportStats final : public RTCStats {
class RTC_EXPORT RTCAudioPlayoutStats final : public RTCStats { class RTC_EXPORT RTCAudioPlayoutStats final : public RTCStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCAudioPlayoutStats(const std::string& id, Timestamp timestamp); RTCAudioPlayoutStats(const std::string& id, Timestamp timestamp);
RTCAudioPlayoutStats(const RTCAudioPlayoutStats& other);
~RTCAudioPlayoutStats() override; ~RTCAudioPlayoutStats() override;
RTCStatsMember<std::string> kind; RTCStatsMember<std::string> kind;

7
pc/rtc_stats_collector_unittest.cc
View File

@ -3721,15 +3721,12 @@ class RTCTestStats : public RTCStats {
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCTestStats(const std::string& id, Timestamp timestamp) RTCTestStats(const std::string& id, Timestamp timestamp)
: RTCStats(id, timestamp) {} : RTCStats(id, timestamp), dummy_stat("dummyStat") {}
RTCStatsMember<int32_t> dummy_stat; RTCStatsMember<int32_t> dummy_stat;
}; };
WEBRTC_RTCSTATS_IMPL(RTCTestStats, WEBRTC_RTCSTATS_IMPL(RTCTestStats, RTCStats, "test-stats", &dummy_stat)
RTCStats,
"test-stats",
AttributeInit("dummyStat", &dummy_stat))
// Overrides the stats collection to verify thread usage and that the resulting // Overrides the stats collection to verify thread usage and that the resulting
// partial reports are merged. // partial reports are merged.

91
stats/attribute.cc
View File

@ -33,22 +33,66 @@ struct VisitIsSequence {
struct VisitIsEqual { struct VisitIsEqual {
template <typename T> template <typename T>
bool operator()(const RTCStatsMember<T>* attribute) { bool operator()(const RTCStatsMember<T>* attribute) {
if (!other.holds_alternative<T>()) { return attribute->IsEqual(other);
return false;
}
absl::optional<T> attribute_as_optional =
attribute->has_value() ? absl::optional<T>(attribute->value())
: absl::nullopt;
return attribute_as_optional == other.as_optional<T>();
} }
const Attribute& other; const RTCStatsMemberInterface& other;
}; };
} // namespace } // namespace
Attribute::~Attribute() {}
// static
Attribute Attribute::FromMemberInterface(
const RTCStatsMemberInterface* member) {
switch (member->type()) {
case RTCStatsMemberInterface::Type::kBool:
return Attribute(&member->cast_to<RTCStatsMember<bool>>());
case RTCStatsMemberInterface::Type::kInt32:
return Attribute(&member->cast_to<RTCStatsMember<int32_t>>());
case RTCStatsMemberInterface::Type::kUint32:
return Attribute(&member->cast_to<RTCStatsMember<uint32_t>>());
case RTCStatsMemberInterface::Type::kInt64:
return Attribute(&member->cast_to<RTCStatsMember<int64_t>>());
case RTCStatsMemberInterface::Type::kUint64:
return Attribute(&member->cast_to<RTCStatsMember<uint64_t>>());
case RTCStatsMemberInterface::Type::kDouble:
return Attribute(&member->cast_to<RTCStatsMember<double>>());
case RTCStatsMemberInterface::Type::kString:
return Attribute(&member->cast_to<RTCStatsMember<std::string>>());
case RTCStatsMemberInterface::Type::kSequenceBool:
return Attribute(&member->cast_to<RTCStatsMember<std::vector<bool>>>());
case RTCStatsMemberInterface::Type::kSequenceInt32:
return Attribute(
&member->cast_to<RTCStatsMember<std::vector<int32_t>>>());
case RTCStatsMemberInterface::Type::kSequenceUint32:
return Attribute(
&member->cast_to<RTCStatsMember<std::vector<uint32_t>>>());
case RTCStatsMemberInterface::Type::kSequenceInt64:
return Attribute(
&member->cast_to<RTCStatsMember<std::vector<int64_t>>>());
case RTCStatsMemberInterface::Type::kSequenceUint64:
return Attribute(
&member->cast_to<RTCStatsMember<std::vector<uint64_t>>>());
case RTCStatsMemberInterface::Type::kSequenceDouble:
return Attribute(&member->cast_to<RTCStatsMember<std::vector<double>>>());
case RTCStatsMemberInterface::Type::kSequenceString:
return Attribute(
&member->cast_to<RTCStatsMember<std::vector<std::string>>>());
case RTCStatsMemberInterface::Type::kMapStringUint64:
return Attribute(
&member->cast_to<RTCStatsMember<std::map<std::string, uint64_t>>>());
case RTCStatsMemberInterface::Type::kMapStringDouble:
return Attribute(
&member->cast_to<RTCStatsMember<std::map<std::string, double>>>());
default:
RTC_CHECK_NOTREACHED();
}
}
const char* Attribute::name() const { const char* Attribute::name() const {
return name_; return absl::visit([](const auto* attr) { return attr->name(); }, attribute_);
} }
const Attribute::StatVariant& Attribute::as_variant() const { const Attribute::StatVariant& Attribute::as_variant() const {
@ -60,6 +104,18 @@ bool Attribute::has_value() const {
attribute_); attribute_);
} }
RTCStatsMemberInterface::Type Attribute::type() const {
return absl::visit([](const auto* attr) { return attr->type(); }, attribute_);
}
const RTCStatsMemberInterface* Attribute::member_ptr() const {
return absl::visit(
[](const auto* attr) {
return static_cast<const RTCStatsMemberInterface*>(attr);
},
attribute_);
}
bool Attribute::is_sequence() const { bool Attribute::is_sequence() const {
return absl::visit(VisitIsSequence(), attribute_); return absl::visit(VisitIsSequence(), attribute_);
} }
@ -69,6 +125,11 @@ bool Attribute::is_string() const {
attribute_); attribute_);
} }
bool Attribute::is_defined() const {
return absl::visit([](const auto* attr) { return attr->is_defined(); },
attribute_);
}
std::string Attribute::ValueToString() const { std::string Attribute::ValueToString() const {
return absl::visit([](const auto* attr) { return attr->ValueToString(); }, return absl::visit([](const auto* attr) { return attr->ValueToString(); },
attribute_); attribute_);
@ -79,16 +140,8 @@ std::string Attribute::ValueToJson() const {
attribute_); attribute_);
} }
bool Attribute::operator==(const Attribute& other) const { bool Attribute::IsEqual(const RTCStatsMemberInterface& other) const {
return absl::visit(VisitIsEqual{.other = other}, attribute_); return absl::visit(VisitIsEqual{.other = *other.member_ptr()}, attribute_);
} }
bool Attribute::operator!=(const Attribute& other) const {
return !(*this == other);
}
AttributeInit::AttributeInit(const char* name,
const Attribute::StatVariant& variant)
: name(name), variant(variant) {}
} // namespace webrtc } // namespace webrtc

22
stats/rtc_stats_report_unittest.cc
View File

@ -10,7 +10,6 @@
#include "api/stats/rtc_stats_report.h" #include "api/stats/rtc_stats_report.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"
#include "test/gtest.h" #include "test/gtest.h"
@ -22,45 +21,36 @@ class RTCTestStats1 : public RTCStats {
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCTestStats1(const std::string& id, Timestamp timestamp) RTCTestStats1(const std::string& id, Timestamp timestamp)
: RTCStats(id, timestamp) {} : RTCStats(id, timestamp), integer("integer") {}
RTCStatsMember<int32_t> integer; RTCStatsMember<int32_t> integer;
}; };
WEBRTC_RTCSTATS_IMPL(RTCTestStats1, WEBRTC_RTCSTATS_IMPL(RTCTestStats1, RTCStats, "test-stats-1", &integer)
RTCStats,
"test-stats-1",
AttributeInit("integer", &integer))
class RTCTestStats2 : public RTCStats { class RTCTestStats2 : public RTCStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCTestStats2(const std::string& id, Timestamp timestamp) RTCTestStats2(const std::string& id, Timestamp timestamp)
: RTCStats(id, timestamp) {} : RTCStats(id, timestamp), number("number") {}
RTCStatsMember<double> number; RTCStatsMember<double> number;
}; };
WEBRTC_RTCSTATS_IMPL(RTCTestStats2, WEBRTC_RTCSTATS_IMPL(RTCTestStats2, RTCStats, "test-stats-2", &number)
RTCStats,
"test-stats-2",
AttributeInit("number", &number))
class RTCTestStats3 : public RTCStats { class RTCTestStats3 : public RTCStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCTestStats3(const std::string& id, Timestamp timestamp) RTCTestStats3(const std::string& id, Timestamp timestamp)
: RTCStats(id, timestamp) {} : RTCStats(id, timestamp), string("string") {}
RTCStatsMember<std::string> string; RTCStatsMember<std::string> string;
}; };
WEBRTC_RTCSTATS_IMPL(RTCTestStats3, WEBRTC_RTCSTATS_IMPL(RTCTestStats3, RTCStats, "test-stats-3", &string)
RTCStats,
"test-stats-3",
AttributeInit("string", &string))
TEST(RTCStatsReport, AddAndGetStats) { TEST(RTCStatsReport, AddAndGetStats) {
rtc::scoped_refptr<RTCStatsReport> report = rtc::scoped_refptr<RTCStatsReport> report =

11
stats/rtc_stats_unittest.cc
View File

@ -44,22 +44,19 @@ class RTCChildStats : public RTCStats {
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCChildStats(const std::string& id, Timestamp timestamp) RTCChildStats(const std::string& id, Timestamp timestamp)
: RTCStats(id, timestamp) {} : RTCStats(id, timestamp), child_int("childInt") {}
RTCStatsMember<int32_t> child_int; RTCStatsMember<int32_t> child_int;
}; };
WEBRTC_RTCSTATS_IMPL(RTCChildStats, WEBRTC_RTCSTATS_IMPL(RTCChildStats, RTCStats, "child-stats", &child_int)
RTCStats,
"child-stats",
AttributeInit("childInt", &child_int))
class RTCGrandChildStats : public RTCChildStats { class RTCGrandChildStats : public RTCChildStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCGrandChildStats(const std::string& id, Timestamp timestamp) RTCGrandChildStats(const std::string& id, Timestamp timestamp)
: RTCChildStats(id, timestamp) {} : RTCChildStats(id, timestamp), grandchild_int("grandchildInt") {}
RTCStatsMember<int32_t> grandchild_int; RTCStatsMember<int32_t> grandchild_int;
}; };
@ -67,7 +64,7 @@ class RTCGrandChildStats : public RTCChildStats {
WEBRTC_RTCSTATS_IMPL(RTCGrandChildStats, WEBRTC_RTCSTATS_IMPL(RTCGrandChildStats,
RTCChildStats, RTCChildStats,
"grandchild-stats", "grandchild-stats",
AttributeInit("grandchildInt", &grandchild_int)) &grandchild_int)
TEST(RTCStatsTest, RTCStatsAndAttributes) { TEST(RTCStatsTest, RTCStatsAndAttributes) {
RTCTestStats stats("testId", Timestamp::Micros(42)); RTCTestStats stats("testId", Timestamp::Micros(42));

728
stats/rtcstats_objects.cc
View File

@ -20,110 +20,182 @@ namespace webrtc {
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL(RTCCertificateStats, RTCStats, "certificate", WEBRTC_RTCSTATS_IMPL(RTCCertificateStats, RTCStats, "certificate",
AttributeInit("fingerprint", &fingerprint), &fingerprint,
AttributeInit("fingerprintAlgorithm", &fingerprint_algorithm), &fingerprint_algorithm,
AttributeInit("base64Certificate", &base64_certificate), &base64_certificate,
AttributeInit("issuerCertificateId", &issuer_certificate_id)) &issuer_certificate_id)
// clang-format on // clang-format on
RTCCertificateStats::RTCCertificateStats(std::string id, Timestamp timestamp) RTCCertificateStats::RTCCertificateStats(std::string id, Timestamp timestamp)
: RTCStats(std::move(id), timestamp) {} : RTCStats(std::move(id), timestamp),
fingerprint("fingerprint"),
fingerprint_algorithm("fingerprintAlgorithm"),
base64_certificate("base64Certificate"),
issuer_certificate_id("issuerCertificateId") {}
RTCCertificateStats::RTCCertificateStats(const RTCCertificateStats& other) =
default;
RTCCertificateStats::~RTCCertificateStats() {} RTCCertificateStats::~RTCCertificateStats() {}
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL(RTCCodecStats, RTCStats, "codec", WEBRTC_RTCSTATS_IMPL(RTCCodecStats, RTCStats, "codec",
AttributeInit("transportId", &transport_id), &transport_id,
AttributeInit("payloadType", &payload_type), &payload_type,
AttributeInit("mimeType", &mime_type), &mime_type,
AttributeInit("clockRate", &clock_rate), &clock_rate,
AttributeInit("channels", &channels), &channels,
AttributeInit("sdpFmtpLine", &sdp_fmtp_line)) &sdp_fmtp_line)
// clang-format on // clang-format on
RTCCodecStats::RTCCodecStats(std::string id, Timestamp timestamp) RTCCodecStats::RTCCodecStats(std::string id, Timestamp timestamp)
: RTCStats(std::move(id), timestamp) {} : RTCStats(std::move(id), timestamp),
transport_id("transportId"),
payload_type("payloadType"),
mime_type("mimeType"),
clock_rate("clockRate"),
channels("channels"),
sdp_fmtp_line("sdpFmtpLine") {}
RTCCodecStats::RTCCodecStats(const RTCCodecStats& other) = default;
RTCCodecStats::~RTCCodecStats() {} RTCCodecStats::~RTCCodecStats() {}
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL(RTCDataChannelStats, RTCStats, "data-channel", WEBRTC_RTCSTATS_IMPL(RTCDataChannelStats, RTCStats, "data-channel",
AttributeInit("label", &label), &label,
AttributeInit("protocol", &protocol), &protocol,
AttributeInit("dataChannelIdentifier", &data_channel_identifier), &data_channel_identifier,
AttributeInit("state", &state), &state,
AttributeInit("messagesSent", &messages_sent), &messages_sent,
AttributeInit("bytesSent", &bytes_sent), &bytes_sent,
AttributeInit("messagesReceived", &messages_received), &messages_received,
AttributeInit("bytesReceived", &bytes_received)) &bytes_received)
// clang-format on // clang-format on
RTCDataChannelStats::RTCDataChannelStats(std::string id, Timestamp timestamp) RTCDataChannelStats::RTCDataChannelStats(std::string id, Timestamp timestamp)
: RTCStats(std::move(id), timestamp) {} : RTCStats(std::move(id), timestamp),
label("label"),
protocol("protocol"),
data_channel_identifier("dataChannelIdentifier"),
state("state"),
messages_sent("messagesSent"),
bytes_sent("bytesSent"),
messages_received("messagesReceived"),
bytes_received("bytesReceived") {}
RTCDataChannelStats::RTCDataChannelStats(const RTCDataChannelStats& other) =
default;
RTCDataChannelStats::~RTCDataChannelStats() {} RTCDataChannelStats::~RTCDataChannelStats() {}
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL(RTCIceCandidatePairStats, RTCStats, "candidate-pair", WEBRTC_RTCSTATS_IMPL(RTCIceCandidatePairStats, RTCStats, "candidate-pair",
AttributeInit("transportId", &transport_id), &transport_id,
AttributeInit("localCandidateId", &local_candidate_id), &local_candidate_id,
AttributeInit("remoteCandidateId", &remote_candidate_id), &remote_candidate_id,
AttributeInit("state", &state), &state,
AttributeInit("priority", &priority), &priority,
AttributeInit("nominated", &nominated), &nominated,
AttributeInit("writable", &writable), &writable,
AttributeInit("packetsSent", &packets_sent), &packets_sent,
AttributeInit("packetsReceived", &packets_received), &packets_received,
AttributeInit("bytesSent", &bytes_sent), &bytes_sent,
AttributeInit("bytesReceived", &bytes_received), &bytes_received,
AttributeInit("totalRoundTripTime", &total_round_trip_time), &total_round_trip_time,
AttributeInit("currentRoundTripTime", &current_round_trip_time), &current_round_trip_time,
AttributeInit("availableOutgoingBitrate", &available_outgoing_bitrate), &available_outgoing_bitrate,
AttributeInit("availableIncomingBitrate", &available_incoming_bitrate), &available_incoming_bitrate,
AttributeInit("requestsReceived", &requests_received), &requests_received,
AttributeInit("requestsSent", &requests_sent), &requests_sent,
AttributeInit("responsesReceived", &responses_received), &responses_received,
AttributeInit("responsesSent", &responses_sent), &responses_sent,
AttributeInit("consentRequestsSent", &consent_requests_sent), &consent_requests_sent,
AttributeInit("packetsDiscardedOnSend", &packets_discarded_on_send), &packets_discarded_on_send,
AttributeInit("bytesDiscardedOnSend", &bytes_discarded_on_send), &bytes_discarded_on_send,
AttributeInit("lastPacketReceivedTimestamp", &last_packet_received_timestamp,
&last_packet_received_timestamp), &last_packet_sent_timestamp)
AttributeInit("lastPacketSentTimestamp", &last_packet_sent_timestamp))
// clang-format on // clang-format on
RTCIceCandidatePairStats::RTCIceCandidatePairStats(std::string id, RTCIceCandidatePairStats::RTCIceCandidatePairStats(std::string id,
Timestamp timestamp) Timestamp timestamp)
: RTCStats(std::move(id), timestamp) {} : RTCStats(std::move(id), timestamp),
transport_id("transportId"),
local_candidate_id("localCandidateId"),
remote_candidate_id("remoteCandidateId"),
state("state"),
priority("priority"),
nominated("nominated"),
writable("writable"),
packets_sent("packetsSent"),
packets_received("packetsReceived"),
bytes_sent("bytesSent"),
bytes_received("bytesReceived"),
total_round_trip_time("totalRoundTripTime"),
current_round_trip_time("currentRoundTripTime"),
available_outgoing_bitrate("availableOutgoingBitrate"),
available_incoming_bitrate("availableIncomingBitrate"),
requests_received("requestsReceived"),
requests_sent("requestsSent"),
responses_received("responsesReceived"),
responses_sent("responsesSent"),
consent_requests_sent("consentRequestsSent"),
packets_discarded_on_send("packetsDiscardedOnSend"),
bytes_discarded_on_send("bytesDiscardedOnSend"),
last_packet_received_timestamp("lastPacketReceivedTimestamp"),
last_packet_sent_timestamp("lastPacketSentTimestamp") {}
RTCIceCandidatePairStats::RTCIceCandidatePairStats(
const RTCIceCandidatePairStats& other) = default;
RTCIceCandidatePairStats::~RTCIceCandidatePairStats() {} RTCIceCandidatePairStats::~RTCIceCandidatePairStats() {}
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL(RTCIceCandidateStats, RTCStats, "abstract-ice-candidate", WEBRTC_RTCSTATS_IMPL(RTCIceCandidateStats, RTCStats, "abstract-ice-candidate",
AttributeInit("transportId", &transport_id), &transport_id,
AttributeInit("isRemote", &is_remote), &is_remote,
AttributeInit("networkType", &network_type), &network_type,
AttributeInit("ip", &ip), &ip,
AttributeInit("address", &address), &address,
AttributeInit("port", &port), &port,
AttributeInit("protocol", &protocol), &protocol,
AttributeInit("relayProtocol", &relay_protocol), &relay_protocol,
AttributeInit("candidateType", &candidate_type), &candidate_type,
AttributeInit("priority", &priority), &priority,
AttributeInit("url", &url), &url,
AttributeInit("foundation", &foundation), &foundation,
AttributeInit("relatedAddress", &related_address), &related_address,
AttributeInit("relatedPort", &related_port), &related_port,
AttributeInit("usernameFragment", &username_fragment), &username_fragment,
AttributeInit("tcpType", &tcp_type), &tcp_type,
AttributeInit("vpn", &vpn), &vpn,
AttributeInit("networkAdapterType", &network_adapter_type)) &network_adapter_type)
// clang-format on // clang-format on
RTCIceCandidateStats::RTCIceCandidateStats(std::string id, RTCIceCandidateStats::RTCIceCandidateStats(std::string id,
Timestamp timestamp, Timestamp timestamp,
bool is_remote) bool is_remote)
: RTCStats(std::move(id), timestamp), is_remote(is_remote) {} : RTCStats(std::move(id), timestamp),
transport_id("transportId"),
is_remote("isRemote", is_remote),
network_type("networkType"),
ip("ip"),
address("address"),
port("port"),
protocol("protocol"),
relay_protocol("relayProtocol"),
candidate_type("candidateType"),
priority("priority"),
url("url"),
foundation("foundation"),
related_address("relatedAddress"),
related_port("relatedPort"),
username_fragment("usernameFragment"),
tcp_type("tcpType"),
vpn("vpn"),
network_adapter_type("networkAdapterType") {}
RTCIceCandidateStats::RTCIceCandidateStats(const RTCIceCandidateStats& other) =
default;
RTCIceCandidateStats::~RTCIceCandidateStats() {} RTCIceCandidateStats::~RTCIceCandidateStats() {}
@ -157,172 +229,286 @@ const char* RTCRemoteIceCandidateStats::type() const {
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL(RTCPeerConnectionStats, RTCStats, "peer-connection", WEBRTC_RTCSTATS_IMPL(RTCPeerConnectionStats, RTCStats, "peer-connection",
AttributeInit("dataChannelsOpened", &data_channels_opened), &data_channels_opened,
AttributeInit("dataChannelsClosed", &data_channels_closed)) &data_channels_closed)
// clang-format on // clang-format on
RTCPeerConnectionStats::RTCPeerConnectionStats(std::string id, RTCPeerConnectionStats::RTCPeerConnectionStats(std::string id,
Timestamp timestamp) Timestamp timestamp)
: RTCStats(std::move(id), timestamp) {} : RTCStats(std::move(id), timestamp),
data_channels_opened("dataChannelsOpened"),
data_channels_closed("dataChannelsClosed") {}
RTCPeerConnectionStats::RTCPeerConnectionStats(
const RTCPeerConnectionStats& other) = default;
RTCPeerConnectionStats::~RTCPeerConnectionStats() {} RTCPeerConnectionStats::~RTCPeerConnectionStats() {}
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL(RTCRtpStreamStats, RTCStats, "rtp", WEBRTC_RTCSTATS_IMPL(RTCRtpStreamStats, RTCStats, "rtp",
AttributeInit("ssrc", &ssrc), &ssrc,
AttributeInit("kind", &kind), &kind,
AttributeInit("transportId", &transport_id), &transport_id,
AttributeInit("codecId", &codec_id)) &codec_id)
// clang-format on // clang-format on
RTCRtpStreamStats::RTCRtpStreamStats(std::string id, Timestamp timestamp) RTCRtpStreamStats::RTCRtpStreamStats(std::string id, Timestamp timestamp)
: RTCStats(std::move(id), timestamp) {} : RTCStats(std::move(id), timestamp),
ssrc("ssrc"),
kind("kind"),
transport_id("transportId"),
codec_id("codecId") {}
RTCRtpStreamStats::RTCRtpStreamStats(const RTCRtpStreamStats& other) = default;
RTCRtpStreamStats::~RTCRtpStreamStats() {} RTCRtpStreamStats::~RTCRtpStreamStats() {}
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL( WEBRTC_RTCSTATS_IMPL(
RTCReceivedRtpStreamStats, RTCRtpStreamStats, "received-rtp", RTCReceivedRtpStreamStats, RTCRtpStreamStats, "received-rtp",
AttributeInit("jitter", &jitter), &jitter,
AttributeInit("packetsLost", &packets_lost)) &packets_lost)
// clang-format on // clang-format on
RTCReceivedRtpStreamStats::RTCReceivedRtpStreamStats(std::string id, RTCReceivedRtpStreamStats::RTCReceivedRtpStreamStats(std::string id,
Timestamp timestamp) Timestamp timestamp)
: RTCRtpStreamStats(std::move(id), timestamp) {} : RTCRtpStreamStats(std::move(id), timestamp),
jitter("jitter"),
packets_lost("packetsLost") {}
RTCReceivedRtpStreamStats::RTCReceivedRtpStreamStats(
const RTCReceivedRtpStreamStats& other) = default;
RTCReceivedRtpStreamStats::~RTCReceivedRtpStreamStats() {} RTCReceivedRtpStreamStats::~RTCReceivedRtpStreamStats() {}
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL(RTCSentRtpStreamStats, RTCRtpStreamStats, "sent-rtp", WEBRTC_RTCSTATS_IMPL(
AttributeInit("packetsSent", &packets_sent), RTCSentRtpStreamStats, RTCRtpStreamStats, "sent-rtp",
AttributeInit("bytesSent", &bytes_sent)) &packets_sent,
&bytes_sent)
// clang-format on // clang-format on
RTCSentRtpStreamStats::RTCSentRtpStreamStats(std::string id, RTCSentRtpStreamStats::RTCSentRtpStreamStats(std::string id,
Timestamp timestamp) Timestamp timestamp)
: RTCRtpStreamStats(std::move(id), timestamp) {} : RTCRtpStreamStats(std::move(id), timestamp),
packets_sent("packetsSent"),
bytes_sent("bytesSent") {}
RTCSentRtpStreamStats::RTCSentRtpStreamStats(
const RTCSentRtpStreamStats& other) = default;
RTCSentRtpStreamStats::~RTCSentRtpStreamStats() {} RTCSentRtpStreamStats::~RTCSentRtpStreamStats() {}
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL( WEBRTC_RTCSTATS_IMPL(
RTCInboundRtpStreamStats, RTCReceivedRtpStreamStats, "inbound-rtp", RTCInboundRtpStreamStats, RTCReceivedRtpStreamStats, "inbound-rtp",
AttributeInit("playoutId", &playout_id), &track_identifier,
AttributeInit("trackIdentifier", &track_identifier), &mid,
AttributeInit("mid", &mid), &remote_id,
AttributeInit("remoteId", &remote_id), &packets_received,
AttributeInit("packetsReceived", &packets_received), &packets_discarded,
AttributeInit("packetsDiscarded", &packets_discarded), &fec_packets_received,
AttributeInit("fecPacketsReceived", &fec_packets_received), &fec_bytes_received,
AttributeInit("fecBytesReceived", &fec_bytes_received), &fec_packets_discarded,
AttributeInit("fecPacketsDiscarded", &fec_packets_discarded), &fec_ssrc,
AttributeInit("fecSsrc", &fec_ssrc), &bytes_received,
AttributeInit("bytesReceived", &bytes_received), &header_bytes_received,
AttributeInit("headerBytesReceived", &header_bytes_received), &retransmitted_packets_received,
AttributeInit("retransmittedPacketsReceived", &retransmitted_bytes_received,
&retransmitted_packets_received), &rtx_ssrc,
AttributeInit("retransmittedBytesReceived", &retransmitted_bytes_received), &last_packet_received_timestamp,
AttributeInit("rtxSsrc", &rtx_ssrc), &jitter_buffer_delay,
AttributeInit("lastPacketReceivedTimestamp", &jitter_buffer_target_delay,
&last_packet_received_timestamp), &jitter_buffer_minimum_delay,
AttributeInit("jitterBufferDelay", &jitter_buffer_delay), &jitter_buffer_emitted_count,
AttributeInit("jitterBufferTargetDelay", &jitter_buffer_target_delay), &total_samples_received,
AttributeInit("jitterBufferMinimumDelay", &jitter_buffer_minimum_delay), &concealed_samples,
AttributeInit("jitterBufferEmittedCount", &jitter_buffer_emitted_count), &silent_concealed_samples,
AttributeInit("totalSamplesReceived", &total_samples_received), &concealment_events,
AttributeInit("concealedSamples", &concealed_samples), &inserted_samples_for_deceleration,
AttributeInit("silentConcealedSamples", &silent_concealed_samples), &removed_samples_for_acceleration,
AttributeInit("concealmentEvents", &concealment_events), &audio_level,
AttributeInit("insertedSamplesForDeceleration", &total_audio_energy,
&inserted_samples_for_deceleration), &total_samples_duration,
AttributeInit("removedSamplesForAcceleration", &playout_id,
&removed_samples_for_acceleration), &frames_received,
AttributeInit("audioLevel", &audio_level), &frame_width,
AttributeInit("totalAudioEnergy", &total_audio_energy), &frame_height,
AttributeInit("totalSamplesDuration", &total_samples_duration), &frames_per_second,
AttributeInit("framesReceived", &frames_received), &frames_decoded,
AttributeInit("frameWidth", &frame_width), &key_frames_decoded,
AttributeInit("frameHeight", &frame_height), &frames_dropped,
AttributeInit("framesPerSecond", &frames_per_second), &total_decode_time,
AttributeInit("framesDecoded", &frames_decoded), &total_processing_delay,
AttributeInit("keyFramesDecoded", &key_frames_decoded), &total_assembly_time,
AttributeInit("framesDropped", &frames_dropped), &frames_assembled_from_multiple_packets,
AttributeInit("totalDecodeTime", &total_decode_time), &total_inter_frame_delay,
AttributeInit("totalProcessingDelay", &total_processing_delay), &total_squared_inter_frame_delay,
AttributeInit("totalAssemblyTime", &total_assembly_time), &pause_count,
AttributeInit("framesAssembledFromMultiplePackets", &total_pauses_duration,
&frames_assembled_from_multiple_packets), &freeze_count,
AttributeInit("totalInterFrameDelay", &total_inter_frame_delay), &total_freezes_duration,
AttributeInit("totalSquaredInterFrameDelay", &content_type,
&total_squared_inter_frame_delay), &estimated_playout_timestamp,
AttributeInit("pauseCount", &pause_count), &decoder_implementation,
AttributeInit("totalPausesDuration", &total_pauses_duration), &fir_count,
AttributeInit("freezeCount", &freeze_count), &pli_count,
AttributeInit("totalFreezesDuration", &total_freezes_duration), &nack_count,
AttributeInit("contentType", &content_type), &qp_sum,
AttributeInit("estimatedPlayoutTimestamp", &estimated_playout_timestamp), &goog_timing_frame_info,
AttributeInit("decoderImplementation", &decoder_implementation), &power_efficient_decoder,
AttributeInit("firCount", &fir_count), &jitter_buffer_flushes,
AttributeInit("pliCount", &pli_count), &delayed_packet_outage_samples,
AttributeInit("nackCount", &nack_count), &relative_packet_arrival_delay,
AttributeInit("qpSum", &qp_sum), &interruption_count,
AttributeInit("googTimingFrameInfo", &goog_timing_frame_info), &total_interruption_duration,
AttributeInit("powerEfficientDecoder", &power_efficient_decoder), &min_playout_delay)
AttributeInit("jitterBufferFlushes", &jitter_buffer_flushes),
AttributeInit("delayedPacketOutageSamples", &delayed_packet_outage_samples),
AttributeInit("relativePacketArrivalDelay", &relative_packet_arrival_delay),
AttributeInit("interruptionCount", &interruption_count),
AttributeInit("totalInterruptionDuration", &total_interruption_duration),
AttributeInit("minPlayoutDelay", &min_playout_delay))
// clang-format on // clang-format on
RTCInboundRtpStreamStats::RTCInboundRtpStreamStats(std::string id, RTCInboundRtpStreamStats::RTCInboundRtpStreamStats(std::string id,
Timestamp timestamp) Timestamp timestamp)
: RTCReceivedRtpStreamStats(std::move(id), timestamp) {} : RTCReceivedRtpStreamStats(std::move(id), timestamp),
playout_id("playoutId"),
track_identifier("trackIdentifier"),
mid("mid"),
remote_id("remoteId"),
packets_received("packetsReceived"),
packets_discarded("packetsDiscarded"),
fec_packets_received("fecPacketsReceived"),
fec_bytes_received("fecBytesReceived"),
fec_packets_discarded("fecPacketsDiscarded"),
fec_ssrc("fecSsrc"),
bytes_received("bytesReceived"),
header_bytes_received("headerBytesReceived"),
retransmitted_packets_received("retransmittedPacketsReceived"),
retransmitted_bytes_received("retransmittedBytesReceived"),
rtx_ssrc("rtxSsrc"),
last_packet_received_timestamp("lastPacketReceivedTimestamp"),
jitter_buffer_delay("jitterBufferDelay"),
jitter_buffer_target_delay("jitterBufferTargetDelay"),
jitter_buffer_minimum_delay("jitterBufferMinimumDelay"),
jitter_buffer_emitted_count("jitterBufferEmittedCount"),
total_samples_received("totalSamplesReceived"),
concealed_samples("concealedSamples"),
silent_concealed_samples("silentConcealedSamples"),
concealment_events("concealmentEvents"),
inserted_samples_for_deceleration("insertedSamplesForDeceleration"),
removed_samples_for_acceleration("removedSamplesForAcceleration"),
audio_level("audioLevel"),
total_audio_energy("totalAudioEnergy"),
total_samples_duration("totalSamplesDuration"),
frames_received("framesReceived"),
frame_width("frameWidth"),
frame_height("frameHeight"),
frames_per_second("framesPerSecond"),
frames_decoded("framesDecoded"),
key_frames_decoded("keyFramesDecoded"),
frames_dropped("framesDropped"),
total_decode_time("totalDecodeTime"),
total_processing_delay("totalProcessingDelay"),
total_assembly_time("totalAssemblyTime"),
frames_assembled_from_multiple_packets(
"framesAssembledFromMultiplePackets"),
total_inter_frame_delay("totalInterFrameDelay"),
total_squared_inter_frame_delay("totalSquaredInterFrameDelay"),
pause_count("pauseCount"),
total_pauses_duration("totalPausesDuration"),
freeze_count("freezeCount"),
total_freezes_duration("totalFreezesDuration"),
content_type("contentType"),
estimated_playout_timestamp("estimatedPlayoutTimestamp"),
decoder_implementation("decoderImplementation"),
fir_count("firCount"),
pli_count("pliCount"),
nack_count("nackCount"),
qp_sum("qpSum"),
goog_timing_frame_info("googTimingFrameInfo"),
power_efficient_decoder("powerEfficientDecoder"),
jitter_buffer_flushes("jitterBufferFlushes"),
delayed_packet_outage_samples("delayedPacketOutageSamples"),
relative_packet_arrival_delay("relativePacketArrivalDelay"),
interruption_count("interruptionCount"),
total_interruption_duration("totalInterruptionDuration"),
min_playout_delay("minPlayoutDelay") {}
RTCInboundRtpStreamStats::RTCInboundRtpStreamStats(
const RTCInboundRtpStreamStats& other) = default;
RTCInboundRtpStreamStats::~RTCInboundRtpStreamStats() {} RTCInboundRtpStreamStats::~RTCInboundRtpStreamStats() {}
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL( WEBRTC_RTCSTATS_IMPL(
RTCOutboundRtpStreamStats, RTCSentRtpStreamStats, "outbound-rtp", RTCOutboundRtpStreamStats, RTCSentRtpStreamStats, "outbound-rtp",
AttributeInit("mediaSourceId", &media_source_id), &media_source_id,
AttributeInit("remoteId", &remote_id), &remote_id,
AttributeInit("mid", &mid), &mid,
AttributeInit("rid", &rid), &rid,
AttributeInit("retransmittedPacketsSent", &retransmitted_packets_sent), &retransmitted_packets_sent,
AttributeInit("headerBytesSent", &header_bytes_sent), &header_bytes_sent,
AttributeInit("retransmittedBytesSent", &retransmitted_bytes_sent), &retransmitted_bytes_sent,
AttributeInit("targetBitrate", &target_bitrate), &target_bitrate,
AttributeInit("framesEncoded", &frames_encoded), &frames_encoded,
AttributeInit("keyFramesEncoded", &key_frames_encoded), &key_frames_encoded,
AttributeInit("totalEncodeTime", &total_encode_time), &total_encode_time,
AttributeInit("totalEncodedBytesTarget", &total_encoded_bytes_target), &total_encoded_bytes_target,
AttributeInit("frameWidth", &frame_width), &frame_width,
AttributeInit("frameHeight", &frame_height), &frame_height,
AttributeInit("framesPerSecond", &frames_per_second), &frames_per_second,
AttributeInit("framesSent", &frames_sent), &frames_sent,
AttributeInit("hugeFramesSent", &huge_frames_sent), &huge_frames_sent,
AttributeInit("totalPacketSendDelay", &total_packet_send_delay), &total_packet_send_delay,
AttributeInit("qualityLimitationReason", &quality_limitation_reason), &quality_limitation_reason,
AttributeInit("qualityLimitationDurations", &quality_limitation_durations), &quality_limitation_durations,
AttributeInit("qualityLimitationResolutionChanges", &quality_limitation_resolution_changes,
&quality_limitation_resolution_changes), &content_type,
AttributeInit("contentType", &content_type), &encoder_implementation,
AttributeInit("encoderImplementation", &encoder_implementation), &fir_count,
AttributeInit("firCount", &fir_count), &pli_count,
AttributeInit("pliCount", &pli_count), &nack_count,
AttributeInit("nackCount", &nack_count), &qp_sum,
AttributeInit("qpSum", &qp_sum), &active,
AttributeInit("active", &active), &power_efficient_encoder,
AttributeInit("powerEfficientEncoder", &power_efficient_encoder), &scalability_mode,
AttributeInit("scalabilityMode", &scalability_mode), &rtx_ssrc)
AttributeInit("rtxSsrc", &rtx_ssrc))
// clang-format on // clang-format on
RTCOutboundRtpStreamStats::RTCOutboundRtpStreamStats(std::string id, RTCOutboundRtpStreamStats::RTCOutboundRtpStreamStats(std::string id,
Timestamp timestamp) Timestamp timestamp)
: RTCSentRtpStreamStats(std::move(id), timestamp) {} : RTCSentRtpStreamStats(std::move(id), timestamp),
media_source_id("mediaSourceId"),
remote_id("remoteId"),
mid("mid"),
rid("rid"),
retransmitted_packets_sent("retransmittedPacketsSent"),
header_bytes_sent("headerBytesSent"),
retransmitted_bytes_sent("retransmittedBytesSent"),
target_bitrate("targetBitrate"),
frames_encoded("framesEncoded"),
key_frames_encoded("keyFramesEncoded"),
total_encode_time("totalEncodeTime"),
total_encoded_bytes_target("totalEncodedBytesTarget"),
frame_width("frameWidth"),
frame_height("frameHeight"),
frames_per_second("framesPerSecond"),
frames_sent("framesSent"),
huge_frames_sent("hugeFramesSent"),
total_packet_send_delay("totalPacketSendDelay"),
quality_limitation_reason("qualityLimitationReason"),
quality_limitation_durations("qualityLimitationDurations"),
quality_limitation_resolution_changes(
"qualityLimitationResolutionChanges"),
content_type("contentType"),
encoder_implementation("encoderImplementation"),
fir_count("firCount"),
pli_count("pliCount"),
nack_count("nackCount"),
qp_sum("qpSum"),
active("active"),
power_efficient_encoder("powerEfficientEncoder"),
scalability_mode("scalabilityMode"),
rtx_ssrc("rtxSsrc") {}
RTCOutboundRtpStreamStats::RTCOutboundRtpStreamStats(
const RTCOutboundRtpStreamStats& other) = default;
RTCOutboundRtpStreamStats::~RTCOutboundRtpStreamStats() {} RTCOutboundRtpStreamStats::~RTCOutboundRtpStreamStats() {}
@ -330,17 +516,25 @@ RTCOutboundRtpStreamStats::~RTCOutboundRtpStreamStats() {}
WEBRTC_RTCSTATS_IMPL( WEBRTC_RTCSTATS_IMPL(
RTCRemoteInboundRtpStreamStats, RTCReceivedRtpStreamStats, RTCRemoteInboundRtpStreamStats, RTCReceivedRtpStreamStats,
"remote-inbound-rtp", "remote-inbound-rtp",
AttributeInit("localId", &local_id), &local_id,
AttributeInit("roundTripTime", &round_trip_time), &round_trip_time,
AttributeInit("fractionLost", &fraction_lost), &fraction_lost,
AttributeInit("totalRoundTripTime", &total_round_trip_time), &total_round_trip_time,
AttributeInit("roundTripTimeMeasurements", &round_trip_time_measurements)) &round_trip_time_measurements)
// clang-format on // clang-format on
RTCRemoteInboundRtpStreamStats::RTCRemoteInboundRtpStreamStats( RTCRemoteInboundRtpStreamStats::RTCRemoteInboundRtpStreamStats(
std::string id, std::string id,
Timestamp timestamp) Timestamp timestamp)
: RTCReceivedRtpStreamStats(std::move(id), timestamp) {} : RTCReceivedRtpStreamStats(std::move(id), timestamp),
local_id("localId"),
round_trip_time("roundTripTime"),
fraction_lost("fractionLost"),
total_round_trip_time("totalRoundTripTime"),
round_trip_time_measurements("roundTripTimeMeasurements") {}
RTCRemoteInboundRtpStreamStats::RTCRemoteInboundRtpStreamStats(
const RTCRemoteInboundRtpStreamStats& other) = default;
RTCRemoteInboundRtpStreamStats::~RTCRemoteInboundRtpStreamStats() {} RTCRemoteInboundRtpStreamStats::~RTCRemoteInboundRtpStreamStats() {}
@ -348,100 +542,156 @@ RTCRemoteInboundRtpStreamStats::~RTCRemoteInboundRtpStreamStats() {}
WEBRTC_RTCSTATS_IMPL( WEBRTC_RTCSTATS_IMPL(
RTCRemoteOutboundRtpStreamStats, RTCSentRtpStreamStats, RTCRemoteOutboundRtpStreamStats, RTCSentRtpStreamStats,
"remote-outbound-rtp", "remote-outbound-rtp",
AttributeInit("localId", &local_id), &local_id,
AttributeInit("remoteTimestamp", &remote_timestamp), &remote_timestamp,
AttributeInit("reportsSent", &reports_sent), &reports_sent,
AttributeInit("roundTripTime", &round_trip_time), &round_trip_time,
AttributeInit("roundTripTimeMeasurements", &round_trip_time_measurements), &round_trip_time_measurements,
AttributeInit("totalRoundTripTime", &total_round_trip_time)) &total_round_trip_time)
// clang-format on // clang-format on
RTCRemoteOutboundRtpStreamStats::RTCRemoteOutboundRtpStreamStats( RTCRemoteOutboundRtpStreamStats::RTCRemoteOutboundRtpStreamStats(
std::string id, std::string id,
Timestamp timestamp) Timestamp timestamp)
: RTCSentRtpStreamStats(std::move(id), timestamp) {} : RTCSentRtpStreamStats(std::move(id), timestamp),
local_id("localId"),
remote_timestamp("remoteTimestamp"),
reports_sent("reportsSent"),
round_trip_time("roundTripTime"),
round_trip_time_measurements("roundTripTimeMeasurements"),
total_round_trip_time("totalRoundTripTime") {}
RTCRemoteOutboundRtpStreamStats::RTCRemoteOutboundRtpStreamStats(
const RTCRemoteOutboundRtpStreamStats& other) = default;
RTCRemoteOutboundRtpStreamStats::~RTCRemoteOutboundRtpStreamStats() {} RTCRemoteOutboundRtpStreamStats::~RTCRemoteOutboundRtpStreamStats() {}
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL(RTCMediaSourceStats, RTCStats, "parent-media-source", WEBRTC_RTCSTATS_IMPL(RTCMediaSourceStats, RTCStats, "parent-media-source",
AttributeInit("trackIdentifier", &track_identifier), &track_identifier,
AttributeInit("kind", &kind)) &kind)
// clang-format on // clang-format on
RTCMediaSourceStats::RTCMediaSourceStats(std::string id, Timestamp timestamp) RTCMediaSourceStats::RTCMediaSourceStats(std::string id, Timestamp timestamp)
: RTCStats(std::move(id), timestamp) {} : RTCStats(std::move(id), timestamp),
track_identifier("trackIdentifier"),
kind("kind") {}
RTCMediaSourceStats::RTCMediaSourceStats(const RTCMediaSourceStats& other) =
default;
RTCMediaSourceStats::~RTCMediaSourceStats() {} RTCMediaSourceStats::~RTCMediaSourceStats() {}
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL(RTCAudioSourceStats, RTCMediaSourceStats, "media-source", WEBRTC_RTCSTATS_IMPL(RTCAudioSourceStats, RTCMediaSourceStats, "media-source",
AttributeInit("audioLevel", &audio_level), &audio_level,
AttributeInit("totalAudioEnergy", &total_audio_energy), &total_audio_energy,
AttributeInit("totalSamplesDuration", &total_samples_duration), &total_samples_duration,
AttributeInit("echoReturnLoss", &echo_return_loss), &echo_return_loss,
AttributeInit("echoReturnLossEnhancement", &echo_return_loss_enhancement)) &echo_return_loss_enhancement)
// clang-format on // clang-format on
RTCAudioSourceStats::RTCAudioSourceStats(std::string id, Timestamp timestamp) RTCAudioSourceStats::RTCAudioSourceStats(std::string id, Timestamp timestamp)
: RTCMediaSourceStats(std::move(id), timestamp) {} : RTCMediaSourceStats(std::move(id), timestamp),
audio_level("audioLevel"),
total_audio_energy("totalAudioEnergy"),
total_samples_duration("totalSamplesDuration"),
echo_return_loss("echoReturnLoss"),
echo_return_loss_enhancement("echoReturnLossEnhancement") {}
RTCAudioSourceStats::RTCAudioSourceStats(const RTCAudioSourceStats& other) =
default;
RTCAudioSourceStats::~RTCAudioSourceStats() {} RTCAudioSourceStats::~RTCAudioSourceStats() {}
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL(RTCVideoSourceStats, RTCMediaSourceStats, "media-source", WEBRTC_RTCSTATS_IMPL(RTCVideoSourceStats, RTCMediaSourceStats, "media-source",
AttributeInit("width", &width), &width,
AttributeInit("height", &height), &height,
AttributeInit("frames", &frames), &frames,
AttributeInit("framesPerSecond", &frames_per_second)) &frames_per_second)
// clang-format on // clang-format on
RTCVideoSourceStats::RTCVideoSourceStats(std::string id, Timestamp timestamp) RTCVideoSourceStats::RTCVideoSourceStats(std::string id, Timestamp timestamp)
: RTCMediaSourceStats(std::move(id), timestamp) {} : RTCMediaSourceStats(std::move(id), timestamp),
width("width"),
height("height"),
frames("frames"),
frames_per_second("framesPerSecond") {}
RTCVideoSourceStats::RTCVideoSourceStats(const RTCVideoSourceStats& other) =
default;
RTCVideoSourceStats::~RTCVideoSourceStats() {} RTCVideoSourceStats::~RTCVideoSourceStats() {}
// clang-format off // clang-format off
WEBRTC_RTCSTATS_IMPL(RTCTransportStats, RTCStats, "transport", WEBRTC_RTCSTATS_IMPL(RTCTransportStats, RTCStats, "transport",
AttributeInit("bytesSent", &bytes_sent), &bytes_sent,
AttributeInit("packetsSent", &packets_sent), &packets_sent,
AttributeInit("bytesReceived", &bytes_received), &bytes_received,
AttributeInit("packetsReceived", &packets_received), &packets_received,
AttributeInit("rtcpTransportStatsId", &rtcp_transport_stats_id), &rtcp_transport_stats_id,
AttributeInit("dtlsState", &dtls_state), &dtls_state,
AttributeInit("selectedCandidatePairId", &selected_candidate_pair_id), &selected_candidate_pair_id,
AttributeInit("localCertificateId", &local_certificate_id), &local_certificate_id,
AttributeInit("remoteCertificateId", &remote_certificate_id), &remote_certificate_id,
AttributeInit("tlsVersion", &tls_version), &tls_version,
AttributeInit("dtlsCipher", &dtls_cipher), &dtls_cipher,
AttributeInit("dtlsRole", &dtls_role), &dtls_role,
AttributeInit("srtpCipher", &srtp_cipher), &srtp_cipher,
AttributeInit("selectedCandidatePairChanges", &selected_candidate_pair_changes,
&selected_candidate_pair_changes), &ice_role,
AttributeInit("iceRole", &ice_role), &ice_local_username_fragment,
AttributeInit("iceLocalUsernameFragment", &ice_local_username_fragment), &ice_state)
AttributeInit("iceState", &ice_state))
// clang-format on // clang-format on
RTCTransportStats::RTCTransportStats(std::string id, Timestamp timestamp) RTCTransportStats::RTCTransportStats(std::string id, Timestamp timestamp)
: RTCStats(std::move(id), timestamp) {} : RTCStats(std::move(id), timestamp),
bytes_sent("bytesSent"),
packets_sent("packetsSent"),
bytes_received("bytesReceived"),
packets_received("packetsReceived"),
rtcp_transport_stats_id("rtcpTransportStatsId"),
dtls_state("dtlsState"),
selected_candidate_pair_id("selectedCandidatePairId"),
local_certificate_id("localCertificateId"),
remote_certificate_id("remoteCertificateId"),
tls_version("tlsVersion"),
dtls_cipher("dtlsCipher"),
dtls_role("dtlsRole"),
srtp_cipher("srtpCipher"),
selected_candidate_pair_changes("selectedCandidatePairChanges"),
ice_role("iceRole"),
ice_local_username_fragment("iceLocalUsernameFragment"),
ice_state("iceState") {}
RTCTransportStats::RTCTransportStats(const RTCTransportStats& other) = default;
RTCTransportStats::~RTCTransportStats() {} RTCTransportStats::~RTCTransportStats() {}
// clang-format off
WEBRTC_RTCSTATS_IMPL(RTCAudioPlayoutStats, RTCStats, "media-playout",
AttributeInit("kind", &kind),
AttributeInit("synthesizedSamplesDuration", &synthesized_samples_duration),
AttributeInit("synthesizedSamplesEvents", &synthesized_samples_events),
AttributeInit("totalSamplesDuration", &total_samples_duration),
AttributeInit("totalPlayoutDelay", &total_playout_delay),
AttributeInit("totalSamplesCount", &total_samples_count))
// clang-format on
RTCAudioPlayoutStats::RTCAudioPlayoutStats(const std::string& id, RTCAudioPlayoutStats::RTCAudioPlayoutStats(const std::string& id,
Timestamp timestamp) Timestamp timestamp)
: RTCStats(std::move(id), timestamp), kind("audio") {} : RTCStats(std::move(id), timestamp),
kind("kind", "audio"),
synthesized_samples_duration("synthesizedSamplesDuration"),
synthesized_samples_events("synthesizedSamplesEvents"),
total_samples_duration("totalSamplesDuration"),
total_playout_delay("totalPlayoutDelay"),
total_samples_count("totalSamplesCount") {}
RTCAudioPlayoutStats::RTCAudioPlayoutStats(const RTCAudioPlayoutStats& other) =
default;
RTCAudioPlayoutStats::~RTCAudioPlayoutStats() {} RTCAudioPlayoutStats::~RTCAudioPlayoutStats() {}
// clang-format off
WEBRTC_RTCSTATS_IMPL(RTCAudioPlayoutStats, RTCStats, "media-playout",
&kind,
&synthesized_samples_duration,
&synthesized_samples_events,
&total_samples_duration,
&total_playout_delay,
&total_samples_count)
// clang-format on
} // namespace webrtc } // namespace webrtc

70
stats/test/rtc_test_stats.cc
View File

@ -10,7 +10,6 @@
#include "stats/test/rtc_test_stats.h" #include "stats/test/rtc_test_stats.h"
#include "api/stats/attribute.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
namespace webrtc { namespace webrtc {
@ -18,25 +17,60 @@ namespace webrtc {
WEBRTC_RTCSTATS_IMPL(RTCTestStats, WEBRTC_RTCSTATS_IMPL(RTCTestStats,
RTCStats, RTCStats,
"test-stats", "test-stats",
AttributeInit("mBool", &m_bool), &m_bool,
AttributeInit("mInt32", &m_int32), &m_int32,
AttributeInit("mUint32", &m_uint32), &m_uint32,
AttributeInit("mInt64", &m_int64), &m_int64,
AttributeInit("mUint64", &m_uint64), &m_uint64,
AttributeInit("mDouble", &m_double), &m_double,
AttributeInit("mString", &m_string), &m_string,
AttributeInit("mSequenceBool", &m_sequence_bool), &m_sequence_bool,
AttributeInit("mSequenceInt32", &m_sequence_int32), &m_sequence_int32,
AttributeInit("mSequenceUint32", &m_sequence_uint32), &m_sequence_uint32,
AttributeInit("mSequenceInt64", &m_sequence_int64), &m_sequence_int64,
AttributeInit("mSequenceUint64", &m_sequence_uint64), &m_sequence_uint64,
AttributeInit("mSequenceDouble", &m_sequence_double), &m_sequence_double,
AttributeInit("mSequenceString", &m_sequence_string), &m_sequence_string,
AttributeInit("mMapStringUint64", &m_map_string_uint64), &m_map_string_uint64,
AttributeInit("mMapStringDouble", &m_map_string_double)) &m_map_string_double)
RTCTestStats::RTCTestStats(const std::string& id, Timestamp timestamp) RTCTestStats::RTCTestStats(const std::string& id, Timestamp timestamp)
: RTCStats(id, timestamp) {} : RTCStats(id, timestamp),
m_bool("mBool"),
m_int32("mInt32"),
m_uint32("mUint32"),
m_int64("mInt64"),
m_uint64("mUint64"),
m_double("mDouble"),
m_string("mString"),
m_sequence_bool("mSequenceBool"),
m_sequence_int32("mSequenceInt32"),
m_sequence_uint32("mSequenceUint32"),
m_sequence_int64("mSequenceInt64"),
m_sequence_uint64("mSequenceUint64"),
m_sequence_double("mSequenceDouble"),
m_sequence_string("mSequenceString"),
m_map_string_uint64("mMapStringUint64"),
m_map_string_double("mMapStringDouble") {}
RTCTestStats::RTCTestStats(const RTCTestStats& other)
: RTCStats(other.id(), other.timestamp()),
m_bool(other.m_bool),
m_int32(other.m_int32),
m_uint32(other.m_uint32),
m_int64(other.m_int64),
m_uint64(other.m_uint64),
m_double(other.m_double),
m_string(other.m_string),
m_sequence_bool(other.m_sequence_bool),
m_sequence_int32(other.m_sequence_int32),
m_sequence_uint32(other.m_sequence_uint32),
m_sequence_int64(other.m_sequence_int64),
m_sequence_uint64(other.m_sequence_uint64),
m_sequence_double(other.m_sequence_double),
m_sequence_string(other.m_sequence_string),
m_map_string_uint64(other.m_map_string_uint64),
m_map_string_double(other.m_map_string_double) {}
RTCTestStats::~RTCTestStats() {} RTCTestStats::~RTCTestStats() {}

2
stats/test/rtc_test_stats.h
View File

@ -24,7 +24,9 @@ namespace webrtc {
class RTC_EXPORT RTCTestStats : public RTCStats { class RTC_EXPORT RTCTestStats : public RTCStats {
public: public:
WEBRTC_RTCSTATS_DECL(); WEBRTC_RTCSTATS_DECL();
RTCTestStats(const std::string& id, Timestamp timestamp); RTCTestStats(const std::string& id, Timestamp timestamp);
RTCTestStats(const RTCTestStats& other);
~RTCTestStats() override; ~RTCTestStats() override;
RTCStatsMember<bool> m_bool; RTCStatsMember<bool> m_bool;