From d8bbc7858622b6d9c278469aab701ca0b609cddf Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 15 May 2024 05:35:49 +0200 Subject: Merging upstream version 126.0. Signed-off-by: Daniel Baumann --- third_party/libwebrtc/stats/BUILD.gn | 3 + third_party/libwebrtc/stats/attribute.cc | 172 +++++ third_party/libwebrtc/stats/g3doc/stats.md | 27 +- third_party/libwebrtc/stats/rtc_stats.cc | 271 +------- third_party/libwebrtc/stats/rtc_stats_member.cc | 62 ++ .../libwebrtc/stats/rtc_stats_report_unittest.cc | 22 +- third_party/libwebrtc/stats/rtc_stats_unittest.cc | 76 ++- third_party/libwebrtc/stats/rtcstats_objects.cc | 733 +++++++-------------- third_party/libwebrtc/stats/test/rtc_test_stats.cc | 70 +- third_party/libwebrtc/stats/test/rtc_test_stats.h | 2 - 10 files changed, 590 insertions(+), 848 deletions(-) create mode 100644 third_party/libwebrtc/stats/attribute.cc create mode 100644 third_party/libwebrtc/stats/rtc_stats_member.cc (limited to 'third_party/libwebrtc/stats') diff --git a/third_party/libwebrtc/stats/BUILD.gn b/third_party/libwebrtc/stats/BUILD.gn index b2a0c20473..8993272921 100644 --- a/third_party/libwebrtc/stats/BUILD.gn +++ b/third_party/libwebrtc/stats/BUILD.gn @@ -16,7 +16,9 @@ rtc_library("rtc_stats") { visibility = [ "*" ] cflags = [] sources = [ + "attribute.cc", "rtc_stats.cc", + "rtc_stats_member.cc", "rtc_stats_report.cc", "rtcstats_objects.cc", ] @@ -27,6 +29,7 @@ rtc_library("rtc_stats") { "../rtc_base:macromagic", "../rtc_base:stringutils", ] + absl_deps = [ "//third_party/abseil-cpp/absl/types:variant" ] } rtc_library("rtc_stats_test_utils") { diff --git a/third_party/libwebrtc/stats/attribute.cc b/third_party/libwebrtc/stats/attribute.cc new file mode 100644 index 0000000000..fab948b1bd --- /dev/null +++ b/third_party/libwebrtc/stats/attribute.cc @@ -0,0 +1,172 @@ +/* + * Copyright 2024 The WebRTC Project Authors. All rights reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "api/stats/attribute.h" + +#include + +#include "absl/types/variant.h" +#include "rtc_base/arraysize.h" +#include "rtc_base/checks.h" +#include "rtc_base/string_encode.h" +#include "rtc_base/strings/string_builder.h" + +namespace webrtc { + +namespace { + +struct VisitIsSequence { + // Any type of vector is a sequence. + template + bool operator()(const RTCStatsMember>* attribute) { + return true; + } + // Any other type is not. + template + bool operator()(const RTCStatsMember* attribute) { + return false; + } +}; + +// Converts the attribute to string in a JSON-compatible way. +struct VisitToString { + template || std::is_same_v || + std::is_same_v || std::is_same_v, + bool> = true> + std::string ValueToString(const T& value) { + return rtc::ToString(value); + } + // Convert 64-bit integers to doubles before converting to string because JSON + // represents all numbers as floating points with ~15 digits of precision. + template || + std::is_same_v || + std::is_same_v, + bool> = true> + std::string ValueToString(const T& value) { + char buf[32]; + const int len = std::snprintf(&buf[0], arraysize(buf), "%.16g", + static_cast(value)); + RTC_DCHECK_LE(len, arraysize(buf)); + return std::string(&buf[0], len); + } + + // Vector attributes. + template + std::string operator()(const RTCStatsMember>* attribute) { + rtc::StringBuilder sb; + sb << "["; + const char* separator = ""; + constexpr bool element_is_string = std::is_same::value; + for (const T& element : attribute->value()) { + sb << separator; + if (element_is_string) { + sb << "\""; + } + sb << ValueToString(element); + if (element_is_string) { + sb << "\""; + } + separator = ","; + } + sb << "]"; + return sb.Release(); + } + // Map attributes. + template + std::string operator()( + const RTCStatsMember>* attribute) { + rtc::StringBuilder sb; + sb << "{"; + const char* separator = ""; + constexpr bool element_is_string = std::is_same::value; + for (const auto& pair : attribute->value()) { + sb << separator; + sb << "\"" << pair.first << "\":"; + if (element_is_string) { + sb << "\""; + } + sb << ValueToString(pair.second); + if (element_is_string) { + sb << "\""; + } + separator = ","; + } + sb << "}"; + return sb.Release(); + } + // Simple attributes. + template + std::string operator()(const RTCStatsMember* attribute) { + return ValueToString(attribute->value()); + } +}; + +struct VisitIsEqual { + template + bool operator()(const RTCStatsMember* attribute) { + if (!other.holds_alternative()) { + return false; + } + absl::optional attribute_as_optional = + attribute->has_value() ? absl::optional(attribute->value()) + : absl::nullopt; + return attribute_as_optional == other.as_optional(); + } + + const Attribute& other; +}; + +} // namespace + +const char* Attribute::name() const { + return name_; +} + +const Attribute::StatVariant& Attribute::as_variant() const { + return attribute_; +} + +bool Attribute::has_value() const { + return absl::visit([](const auto* attr) { return attr->has_value(); }, + attribute_); +} + +bool Attribute::is_sequence() const { + return absl::visit(VisitIsSequence(), attribute_); +} + +bool Attribute::is_string() const { + return absl::holds_alternative*>( + attribute_); +} + +std::string Attribute::ToString() const { + if (!has_value()) { + return "null"; + } + return absl::visit(VisitToString(), attribute_); +} + +bool Attribute::operator==(const Attribute& other) const { + return absl::visit(VisitIsEqual{.other = other}, 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 diff --git a/third_party/libwebrtc/stats/g3doc/stats.md b/third_party/libwebrtc/stats/g3doc/stats.md index 25127dc36e..7fb89340b8 100644 --- a/third_party/libwebrtc/stats/g3doc/stats.md +++ b/third_party/libwebrtc/stats/g3doc/stats.md @@ -1,18 +1,9 @@ - - - -# getStats in WebRTC - -The WebRTC getStats API is specified in - https://w3c.github.io/webrtc-stats/ -and allows querying information about the current state of a RTCPeerConnection -API and some of its member objects. - -## Adding new statistics to Chrome - -When adding a new standardized `RTCStatsMember` it is necessary to add -it to the Chrome allowlist - chrome/test/data/webrtc/peerconnection_getstats.js -before landing the WebRTC change. This mechanism prevents the accidential -addition and exposure of non-standard attributes and is not required for -`RTCNonStandardStatsMember` which is not exposed to the web API. \ No newline at end of file + + + +# getStats in WebRTC + +The WebRTC getStats API is specified in + https://w3c.github.io/webrtc-stats/ +and allows querying information about the current state of a RTCPeerConnection +API and some of its member objects. diff --git a/third_party/libwebrtc/stats/rtc_stats.cc b/third_party/libwebrtc/stats/rtc_stats.cc index 25bde289c2..e7d72ee3a3 100644 --- a/third_party/libwebrtc/stats/rtc_stats.cc +++ b/third_party/libwebrtc/stats/rtc_stats.cc @@ -12,125 +12,25 @@ #include -#include "rtc_base/arraysize.h" -#include "rtc_base/string_encode.h" #include "rtc_base/strings/string_builder.h" namespace webrtc { -namespace { +RTCStats::RTCStats(const RTCStats& other) + : RTCStats(other.id_, other.timestamp_) {} -// Produces "[a,b,c]". Works for non-vector `RTCStatsMemberInterface::Type` -// types. -template -std::string VectorToString(const std::vector& vector) { - rtc::StringBuilder sb; - sb << "["; - const char* separator = ""; - for (const T& element : vector) { - sb << separator << rtc::ToString(element); - separator = ","; - } - sb << "]"; - return sb.Release(); -} - -// This overload is required because std::vector range loops don't -// return references but objects, causing -Wrange-loop-analysis diagnostics. -std::string VectorToString(const std::vector& vector) { - rtc::StringBuilder sb; - sb << "["; - const char* separator = ""; - for (bool element : vector) { - sb << separator << rtc::ToString(element); - separator = ","; - } - sb << "]"; - return sb.Release(); -} - -// Produces "[\"a\",\"b\",\"c\"]". Works for vectors of both const char* and -// std::string element types. -template -std::string VectorOfStringsToString(const std::vector& strings) { - rtc::StringBuilder sb; - sb << "["; - const char* separator = ""; - for (const T& element : strings) { - sb << separator << "\"" << rtc::ToString(element) << "\""; - separator = ","; - } - sb << "]"; - return sb.Release(); -} - -template -std::string MapToString(const std::map& map) { - rtc::StringBuilder sb; - sb << "{"; - const char* separator = ""; - for (const auto& element : map) { - sb << separator << rtc::ToString(element.first) << ":" - << rtc::ToString(element.second); - separator = ","; - } - sb << "}"; - return sb.Release(); -} - -template -std::string ToStringAsDouble(const T value) { - // JSON represents numbers as floating point numbers with about 15 decimal - // digits of precision. - char buf[32]; - const int len = std::snprintf(&buf[0], arraysize(buf), "%.16g", - static_cast(value)); - RTC_DCHECK_LE(len, arraysize(buf)); - return std::string(&buf[0], len); -} - -template -std::string VectorToStringAsDouble(const std::vector& vector) { - rtc::StringBuilder sb; - sb << "["; - const char* separator = ""; - for (const T& element : vector) { - sb << separator << ToStringAsDouble(element); - separator = ","; - } - sb << "]"; - return sb.Release(); -} - -template -std::string MapToStringAsDouble(const std::map& map) { - rtc::StringBuilder sb; - sb << "{"; - const char* separator = ""; - for (const auto& element : map) { - sb << separator << "\"" << rtc::ToString(element.first) - << "\":" << ToStringAsDouble(element.second); - separator = ","; - } - sb << "}"; - return sb.Release(); -} - -} // namespace +RTCStats::~RTCStats() {} bool RTCStats::operator==(const RTCStats& other) const { if (type() != other.type() || id() != other.id()) return false; - std::vector members = Members(); - std::vector other_members = other.Members(); - RTC_DCHECK_EQ(members.size(), other_members.size()); - for (size_t i = 0; i < members.size(); ++i) { - const RTCStatsMemberInterface* member = members[i]; - const RTCStatsMemberInterface* other_member = other_members[i]; - RTC_DCHECK_EQ(member->type(), other_member->type()); - RTC_DCHECK_EQ(member->name(), other_member->name()); - if (*member != *other_member) + std::vector attributes = Attributes(); + std::vector other_attributes = other.Attributes(); + RTC_DCHECK_EQ(attributes.size(), other_attributes.size()); + for (size_t i = 0; i < attributes.size(); ++i) { + if (attributes[i] != other_attributes[i]) { return false; + } } return true; } @@ -148,150 +48,31 @@ std::string RTCStats::ToJson() const { << "\"," "\"timestamp\":" << timestamp_.us(); - for (const RTCStatsMemberInterface* member : Members()) { - if (member->is_defined()) { - sb << ",\"" << member->name() << "\":"; - if (member->is_string()) - sb << "\"" << member->ValueToJson() << "\""; - else - sb << member->ValueToJson(); + for (const Attribute& attribute : Attributes()) { + if (attribute.has_value()) { + sb << ",\"" << attribute.name() << "\":"; + if (attribute.holds_alternative()) { + sb << "\""; + } + sb << attribute.ToString(); + if (attribute.holds_alternative()) { + sb << "\""; + } } } sb << "}"; return sb.Release(); } -std::vector RTCStats::Members() const { - return MembersOfThisObjectAndAncestors(0); +std::vector RTCStats::Attributes() const { + return AttributesImpl(0); } -std::vector -RTCStats::MembersOfThisObjectAndAncestors(size_t additional_capacity) const { - std::vector members; - members.reserve(additional_capacity); - return members; +std::vector RTCStats::AttributesImpl( + size_t additional_capacity) const { + std::vector attributes; + attributes.reserve(additional_capacity); + return attributes; } -#define WEBRTC_DEFINE_RTCSTATSMEMBER(T, type, is_seq, is_str, to_str, to_json) \ - template <> \ - RTCStatsMemberInterface::Type RTCStatsMember::StaticType() { \ - return type; \ - } \ - template <> \ - bool RTCStatsMember::is_sequence() const { \ - return is_seq; \ - } \ - template <> \ - bool RTCStatsMember::is_string() const { \ - return is_str; \ - } \ - template <> \ - std::string RTCStatsMember::ValueToString() const { \ - RTC_DCHECK(value_.has_value()); \ - return to_str; \ - } \ - template <> \ - std::string RTCStatsMember::ValueToJson() const { \ - RTC_DCHECK(value_.has_value()); \ - return to_json; \ - } \ - template class RTC_EXPORT_TEMPLATE_DEFINE(RTC_EXPORT) RTCStatsMember - -WEBRTC_DEFINE_RTCSTATSMEMBER(bool, - kBool, - false, - false, - rtc::ToString(*value_), - rtc::ToString(*value_)); -WEBRTC_DEFINE_RTCSTATSMEMBER(int32_t, - kInt32, - false, - false, - rtc::ToString(*value_), - rtc::ToString(*value_)); -WEBRTC_DEFINE_RTCSTATSMEMBER(uint32_t, - kUint32, - false, - false, - rtc::ToString(*value_), - rtc::ToString(*value_)); -WEBRTC_DEFINE_RTCSTATSMEMBER(int64_t, - kInt64, - false, - false, - rtc::ToString(*value_), - ToStringAsDouble(*value_)); -WEBRTC_DEFINE_RTCSTATSMEMBER(uint64_t, - kUint64, - false, - false, - rtc::ToString(*value_), - ToStringAsDouble(*value_)); -WEBRTC_DEFINE_RTCSTATSMEMBER(double, - kDouble, - false, - false, - rtc::ToString(*value_), - ToStringAsDouble(*value_)); -WEBRTC_DEFINE_RTCSTATSMEMBER(std::string, - kString, - false, - true, - *value_, - *value_); -WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector, - kSequenceBool, - true, - false, - VectorToString(*value_), - VectorToString(*value_)); -WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector, - kSequenceInt32, - true, - false, - VectorToString(*value_), - VectorToString(*value_)); -WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector, - kSequenceUint32, - true, - false, - VectorToString(*value_), - VectorToString(*value_)); -WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector, - kSequenceInt64, - true, - false, - VectorToString(*value_), - VectorToStringAsDouble(*value_)); -WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector, - kSequenceUint64, - true, - false, - VectorToString(*value_), - VectorToStringAsDouble(*value_)); -WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector, - kSequenceDouble, - true, - false, - VectorToString(*value_), - VectorToStringAsDouble(*value_)); -WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector, - kSequenceString, - true, - false, - VectorOfStringsToString(*value_), - VectorOfStringsToString(*value_)); -WEBRTC_DEFINE_RTCSTATSMEMBER(rtc_stats_internal::MapStringUint64, - kMapStringUint64, - false, - false, - MapToString(*value_), - MapToStringAsDouble(*value_)); -WEBRTC_DEFINE_RTCSTATSMEMBER(rtc_stats_internal::MapStringDouble, - kMapStringDouble, - false, - false, - MapToString(*value_), - MapToStringAsDouble(*value_)); - } // namespace webrtc diff --git a/third_party/libwebrtc/stats/rtc_stats_member.cc b/third_party/libwebrtc/stats/rtc_stats_member.cc new file mode 100644 index 0000000000..3f91988ed0 --- /dev/null +++ b/third_party/libwebrtc/stats/rtc_stats_member.cc @@ -0,0 +1,62 @@ +/* + * Copyright 2023 The WebRTC Project Authors. All rights reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "api/stats/rtc_stats_member.h" + +namespace webrtc { + +#define WEBRTC_DEFINE_RTCSTATSMEMBER(T, type, is_seq, is_str) \ + template <> \ + RTCStatsMemberInterface::Type RTCStatsMember::StaticType() { \ + return type; \ + } \ + template <> \ + bool RTCStatsMember::is_sequence() const { \ + return is_seq; \ + } \ + template <> \ + bool RTCStatsMember::is_string() const { \ + return is_str; \ + } \ + template class RTC_EXPORT_TEMPLATE_DEFINE(RTC_EXPORT) RTCStatsMember + +WEBRTC_DEFINE_RTCSTATSMEMBER(bool, kBool, false, false); +WEBRTC_DEFINE_RTCSTATSMEMBER(int32_t, kInt32, false, false); +WEBRTC_DEFINE_RTCSTATSMEMBER(uint32_t, kUint32, false, false); +WEBRTC_DEFINE_RTCSTATSMEMBER(int64_t, kInt64, false, false); +WEBRTC_DEFINE_RTCSTATSMEMBER(uint64_t, kUint64, false, false); +WEBRTC_DEFINE_RTCSTATSMEMBER(double, kDouble, false, false); +WEBRTC_DEFINE_RTCSTATSMEMBER(std::string, kString, false, true); +WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector, kSequenceBool, true, false); +WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector, kSequenceInt32, true, false); +WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector, + kSequenceUint32, + true, + false); +WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector, kSequenceInt64, true, false); +WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector, + kSequenceUint64, + true, + false); +WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector, kSequenceDouble, true, false); +WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector, + kSequenceString, + true, + false); +WEBRTC_DEFINE_RTCSTATSMEMBER(rtc_stats_internal::MapStringUint64, + kMapStringUint64, + false, + false); +WEBRTC_DEFINE_RTCSTATSMEMBER(rtc_stats_internal::MapStringDouble, + kMapStringDouble, + false, + false); + +} // namespace webrtc diff --git a/third_party/libwebrtc/stats/rtc_stats_report_unittest.cc b/third_party/libwebrtc/stats/rtc_stats_report_unittest.cc index ded0c27609..b3ac0a2db4 100644 --- a/third_party/libwebrtc/stats/rtc_stats_report_unittest.cc +++ b/third_party/libwebrtc/stats/rtc_stats_report_unittest.cc @@ -10,6 +10,7 @@ #include "api/stats/rtc_stats_report.h" +#include "api/stats/attribute.h" #include "api/stats/rtc_stats.h" #include "rtc_base/checks.h" #include "test/gtest.h" @@ -21,36 +22,45 @@ class RTCTestStats1 : public RTCStats { WEBRTC_RTCSTATS_DECL(); RTCTestStats1(const std::string& id, Timestamp timestamp) - : RTCStats(id, timestamp), integer("integer") {} + : RTCStats(id, timestamp) {} RTCStatsMember integer; }; -WEBRTC_RTCSTATS_IMPL(RTCTestStats1, RTCStats, "test-stats-1", &integer) +WEBRTC_RTCSTATS_IMPL(RTCTestStats1, + RTCStats, + "test-stats-1", + AttributeInit("integer", &integer)) class RTCTestStats2 : public RTCStats { public: WEBRTC_RTCSTATS_DECL(); RTCTestStats2(const std::string& id, Timestamp timestamp) - : RTCStats(id, timestamp), number("number") {} + : RTCStats(id, timestamp) {} RTCStatsMember number; }; -WEBRTC_RTCSTATS_IMPL(RTCTestStats2, RTCStats, "test-stats-2", &number) +WEBRTC_RTCSTATS_IMPL(RTCTestStats2, + RTCStats, + "test-stats-2", + AttributeInit("number", &number)) class RTCTestStats3 : public RTCStats { public: WEBRTC_RTCSTATS_DECL(); RTCTestStats3(const std::string& id, Timestamp timestamp) - : RTCStats(id, timestamp), string("string") {} + : RTCStats(id, timestamp) {} RTCStatsMember string; }; -WEBRTC_RTCSTATS_IMPL(RTCTestStats3, RTCStats, "test-stats-3", &string) +WEBRTC_RTCSTATS_IMPL(RTCTestStats3, + RTCStats, + "test-stats-3", + AttributeInit("string", &string)) TEST(RTCStatsReport, AddAndGetStats) { rtc::scoped_refptr report = diff --git a/third_party/libwebrtc/stats/rtc_stats_unittest.cc b/third_party/libwebrtc/stats/rtc_stats_unittest.cc index 249491effd..fd90692875 100644 --- a/third_party/libwebrtc/stats/rtc_stats_unittest.cc +++ b/third_party/libwebrtc/stats/rtc_stats_unittest.cc @@ -44,19 +44,22 @@ class RTCChildStats : public RTCStats { WEBRTC_RTCSTATS_DECL(); RTCChildStats(const std::string& id, Timestamp timestamp) - : RTCStats(id, timestamp), child_int("childInt") {} + : RTCStats(id, timestamp) {} RTCStatsMember child_int; }; -WEBRTC_RTCSTATS_IMPL(RTCChildStats, RTCStats, "child-stats", &child_int) +WEBRTC_RTCSTATS_IMPL(RTCChildStats, + RTCStats, + "child-stats", + AttributeInit("childInt", &child_int)) class RTCGrandChildStats : public RTCChildStats { public: WEBRTC_RTCSTATS_DECL(); RTCGrandChildStats(const std::string& id, Timestamp timestamp) - : RTCChildStats(id, timestamp), grandchild_int("grandchildInt") {} + : RTCChildStats(id, timestamp) {} RTCStatsMember grandchild_int; }; @@ -64,16 +67,16 @@ class RTCGrandChildStats : public RTCChildStats { WEBRTC_RTCSTATS_IMPL(RTCGrandChildStats, RTCChildStats, "grandchild-stats", - &grandchild_int) + AttributeInit("grandchildInt", &grandchild_int)) -TEST(RTCStatsTest, RTCStatsAndMembers) { +TEST(RTCStatsTest, RTCStatsAndAttributes) { RTCTestStats stats("testId", Timestamp::Micros(42)); EXPECT_EQ(stats.id(), "testId"); EXPECT_EQ(stats.timestamp().us(), static_cast(42)); - std::vector members = stats.Members(); - EXPECT_EQ(members.size(), static_cast(16)); - for (const RTCStatsMemberInterface* member : members) { - EXPECT_FALSE(member->is_defined()); + std::vector attributes = stats.Attributes(); + EXPECT_EQ(attributes.size(), static_cast(16)); + for (const auto& attribute : attributes) { + EXPECT_FALSE(attribute.has_value()); } stats.m_bool = true; stats.m_int32 = 123; @@ -104,15 +107,15 @@ TEST(RTCStatsTest, RTCStatsAndMembers) { stats.m_sequence_bool = sequence_bool; stats.m_sequence_int32 = sequence_int32; stats.m_sequence_uint32 = sequence_uint32; - EXPECT_FALSE(stats.m_sequence_int64.is_defined()); + EXPECT_FALSE(stats.m_sequence_int64.has_value()); stats.m_sequence_int64 = sequence_int64; stats.m_sequence_uint64 = sequence_uint64; stats.m_sequence_double = sequence_double; stats.m_sequence_string = sequence_string; stats.m_map_string_uint64 = map_string_uint64; stats.m_map_string_double = map_string_double; - for (const RTCStatsMemberInterface* member : members) { - EXPECT_TRUE(member->is_defined()); + for (const auto& attribute : attributes) { + EXPECT_TRUE(attribute.has_value()); } EXPECT_EQ(*stats.m_bool, true); EXPECT_EQ(*stats.m_int32, static_cast(123)); @@ -217,8 +220,8 @@ TEST(RTCStatsTest, RTCStatsGrandChild) { stats.child_int = 1; stats.grandchild_int = 2; int32_t sum = 0; - for (const RTCStatsMemberInterface* member : stats.Members()) { - sum += *member->cast_to>(); + for (const auto& attribute : stats.Attributes()) { + sum += attribute.get(); } EXPECT_EQ(sum, static_cast(3)); @@ -379,8 +382,8 @@ TEST(RTCStatsTest, RTCStatsPrintsValidJson) { // "mUint32" should not be part of the generated JSON object. int m_uint32; int m_uint64; - EXPECT_FALSE(stats.m_uint32.is_defined()); - EXPECT_FALSE(stats.m_uint64.is_defined()); + EXPECT_FALSE(stats.m_uint32.has_value()); + EXPECT_FALSE(stats.m_uint64.has_value()); EXPECT_FALSE(rtc::GetIntFromJsonObject(json_output, "mUint32", &m_uint32)); EXPECT_FALSE(rtc::GetIntFromJsonObject(json_output, "mUint64", &m_uint64)); @@ -456,45 +459,50 @@ TEST(RTCStatsTest, IsString) { EXPECT_FALSE(stats.m_map_string_double.is_string()); } -TEST(RTCStatsTest, ValueToString) { +TEST(RTCStatsTest, AttributeToString) { RTCTestStats stats("statsId", Timestamp::Micros(42)); stats.m_bool = true; - EXPECT_EQ("true", stats.m_bool.ValueToString()); + EXPECT_EQ("true", stats.GetAttribute(stats.m_bool).ToString()); stats.m_string = "foo"; - EXPECT_EQ("foo", stats.m_string.ValueToString()); + EXPECT_EQ("foo", stats.GetAttribute(stats.m_string).ToString()); stats.m_int32 = -32; - EXPECT_EQ("-32", stats.m_int32.ValueToString()); + EXPECT_EQ("-32", stats.GetAttribute(stats.m_int32).ToString()); stats.m_uint32 = 32; - EXPECT_EQ("32", stats.m_uint32.ValueToString()); + EXPECT_EQ("32", stats.GetAttribute(stats.m_uint32).ToString()); stats.m_int64 = -64; - EXPECT_EQ("-64", stats.m_int64.ValueToString()); + EXPECT_EQ("-64", stats.GetAttribute(stats.m_int64).ToString()); stats.m_uint64 = 64; - EXPECT_EQ("64", stats.m_uint64.ValueToString()); + EXPECT_EQ("64", stats.GetAttribute(stats.m_uint64).ToString()); stats.m_double = 0.5; - EXPECT_EQ("0.5", stats.m_double.ValueToString()); + EXPECT_EQ("0.5", stats.GetAttribute(stats.m_double).ToString()); stats.m_sequence_bool = {true, false}; - EXPECT_EQ("[true,false]", stats.m_sequence_bool.ValueToString()); + EXPECT_EQ("[true,false]", + stats.GetAttribute(stats.m_sequence_bool).ToString()); stats.m_sequence_int32 = {-32, 32}; - EXPECT_EQ("[-32,32]", stats.m_sequence_int32.ValueToString()); + EXPECT_EQ("[-32,32]", stats.GetAttribute(stats.m_sequence_int32).ToString()); stats.m_sequence_uint32 = {64, 32}; - EXPECT_EQ("[64,32]", stats.m_sequence_uint32.ValueToString()); + EXPECT_EQ("[64,32]", stats.GetAttribute(stats.m_sequence_uint32).ToString()); stats.m_sequence_int64 = {-64, 32}; - EXPECT_EQ("[-64,32]", stats.m_sequence_int64.ValueToString()); + EXPECT_EQ("[-64,32]", stats.GetAttribute(stats.m_sequence_int64).ToString()); stats.m_sequence_uint64 = {16, 32}; - EXPECT_EQ("[16,32]", stats.m_sequence_uint64.ValueToString()); + EXPECT_EQ("[16,32]", stats.GetAttribute(stats.m_sequence_uint64).ToString()); stats.m_sequence_double = {0.5, 0.25}; - EXPECT_EQ("[0.5,0.25]", stats.m_sequence_double.ValueToString()); + EXPECT_EQ("[0.5,0.25]", + stats.GetAttribute(stats.m_sequence_double).ToString()); stats.m_sequence_string = {"foo", "bar"}; - EXPECT_EQ("[\"foo\",\"bar\"]", stats.m_sequence_string.ValueToString()); + EXPECT_EQ("[\"foo\",\"bar\"]", + stats.GetAttribute(stats.m_sequence_string).ToString()); stats.m_map_string_uint64 = std::map(); stats.m_map_string_uint64->emplace("foo", 32); stats.m_map_string_uint64->emplace("bar", 64); - EXPECT_EQ("{bar:64,foo:32}", stats.m_map_string_uint64.ValueToString()); + EXPECT_EQ("{\"bar\":64,\"foo\":32}", + stats.GetAttribute(stats.m_map_string_uint64).ToString()); stats.m_map_string_double = std::map(); stats.m_map_string_double->emplace("foo", 0.5); stats.m_map_string_double->emplace("bar", 0.25); - EXPECT_EQ("{bar:0.25,foo:0.5}", stats.m_map_string_double.ValueToString()); + EXPECT_EQ("{\"bar\":0.25,\"foo\":0.5}", + stats.GetAttribute(stats.m_map_string_double).ToString()); } // Death tests. @@ -504,7 +512,7 @@ TEST(RTCStatsTest, ValueToString) { TEST(RTCStatsDeathTest, ValueOfUndefinedMember) { RTCTestStats stats("testId", Timestamp::Micros(0)); - EXPECT_FALSE(stats.m_int32.is_defined()); + EXPECT_FALSE(stats.m_int32.has_value()); EXPECT_DEATH(*stats.m_int32, ""); } diff --git a/third_party/libwebrtc/stats/rtcstats_objects.cc b/third_party/libwebrtc/stats/rtcstats_objects.cc index 77feaf87ba..4c58f45f02 100644 --- a/third_party/libwebrtc/stats/rtcstats_objects.cc +++ b/third_party/libwebrtc/stats/rtcstats_objects.cc @@ -12,6 +12,7 @@ #include +#include "api/stats/attribute.h" #include "api/stats/rtc_stats.h" #include "rtc_base/checks.h" @@ -19,182 +20,110 @@ namespace webrtc { // clang-format off WEBRTC_RTCSTATS_IMPL(RTCCertificateStats, RTCStats, "certificate", - &fingerprint, - &fingerprint_algorithm, - &base64_certificate, - &issuer_certificate_id) + AttributeInit("fingerprint", &fingerprint), + AttributeInit("fingerprintAlgorithm", &fingerprint_algorithm), + AttributeInit("base64Certificate", &base64_certificate), + AttributeInit("issuerCertificateId", &issuer_certificate_id)) // clang-format on RTCCertificateStats::RTCCertificateStats(std::string id, Timestamp timestamp) - : RTCStats(std::move(id), timestamp), - fingerprint("fingerprint"), - fingerprint_algorithm("fingerprintAlgorithm"), - base64_certificate("base64Certificate"), - issuer_certificate_id("issuerCertificateId") {} - -RTCCertificateStats::RTCCertificateStats(const RTCCertificateStats& other) = - default; + : RTCStats(std::move(id), timestamp) {} + RTCCertificateStats::~RTCCertificateStats() {} // clang-format off WEBRTC_RTCSTATS_IMPL(RTCCodecStats, RTCStats, "codec", - &transport_id, - &payload_type, - &mime_type, - &clock_rate, - &channels, - &sdp_fmtp_line) + AttributeInit("transportId", &transport_id), + AttributeInit("payloadType", &payload_type), + AttributeInit("mimeType", &mime_type), + AttributeInit("clockRate", &clock_rate), + AttributeInit("channels", &channels), + AttributeInit("sdpFmtpLine", &sdp_fmtp_line)) // clang-format on RTCCodecStats::RTCCodecStats(std::string id, Timestamp 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; + : RTCStats(std::move(id), timestamp) {} RTCCodecStats::~RTCCodecStats() {} // clang-format off WEBRTC_RTCSTATS_IMPL(RTCDataChannelStats, RTCStats, "data-channel", - &label, - &protocol, - &data_channel_identifier, - &state, - &messages_sent, - &bytes_sent, - &messages_received, - &bytes_received) + AttributeInit("label", &label), + AttributeInit("protocol", &protocol), + AttributeInit("dataChannelIdentifier", &data_channel_identifier), + AttributeInit("state", &state), + AttributeInit("messagesSent", &messages_sent), + AttributeInit("bytesSent", &bytes_sent), + AttributeInit("messagesReceived", &messages_received), + AttributeInit("bytesReceived", &bytes_received)) // clang-format on RTCDataChannelStats::RTCDataChannelStats(std::string id, Timestamp 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; + : RTCStats(std::move(id), timestamp) {} RTCDataChannelStats::~RTCDataChannelStats() {} // clang-format off WEBRTC_RTCSTATS_IMPL(RTCIceCandidatePairStats, RTCStats, "candidate-pair", - &transport_id, - &local_candidate_id, - &remote_candidate_id, - &state, - &priority, - &nominated, - &writable, - &packets_sent, - &packets_received, - &bytes_sent, - &bytes_received, - &total_round_trip_time, - ¤t_round_trip_time, - &available_outgoing_bitrate, - &available_incoming_bitrate, - &requests_received, - &requests_sent, - &responses_received, - &responses_sent, - &consent_requests_sent, - &packets_discarded_on_send, - &bytes_discarded_on_send, - &last_packet_received_timestamp, - &last_packet_sent_timestamp) + AttributeInit("transportId", &transport_id), + AttributeInit("localCandidateId", &local_candidate_id), + AttributeInit("remoteCandidateId", &remote_candidate_id), + AttributeInit("state", &state), + AttributeInit("priority", &priority), + AttributeInit("nominated", &nominated), + AttributeInit("writable", &writable), + AttributeInit("packetsSent", &packets_sent), + AttributeInit("packetsReceived", &packets_received), + AttributeInit("bytesSent", &bytes_sent), + AttributeInit("bytesReceived", &bytes_received), + AttributeInit("totalRoundTripTime", &total_round_trip_time), + AttributeInit("currentRoundTripTime", ¤t_round_trip_time), + AttributeInit("availableOutgoingBitrate", &available_outgoing_bitrate), + AttributeInit("availableIncomingBitrate", &available_incoming_bitrate), + AttributeInit("requestsReceived", &requests_received), + AttributeInit("requestsSent", &requests_sent), + AttributeInit("responsesReceived", &responses_received), + AttributeInit("responsesSent", &responses_sent), + AttributeInit("consentRequestsSent", &consent_requests_sent), + AttributeInit("packetsDiscardedOnSend", &packets_discarded_on_send), + AttributeInit("bytesDiscardedOnSend", &bytes_discarded_on_send), + AttributeInit("lastPacketReceivedTimestamp", + &last_packet_received_timestamp), + AttributeInit("lastPacketSentTimestamp", &last_packet_sent_timestamp)) // clang-format on RTCIceCandidatePairStats::RTCIceCandidatePairStats(std::string id, Timestamp 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; + : RTCStats(std::move(id), timestamp) {} RTCIceCandidatePairStats::~RTCIceCandidatePairStats() {} // clang-format off WEBRTC_RTCSTATS_IMPL(RTCIceCandidateStats, RTCStats, "abstract-ice-candidate", - &transport_id, - &is_remote, - &network_type, - &ip, - &address, - &port, - &protocol, - &relay_protocol, - &candidate_type, - &priority, - &url, - &foundation, - &related_address, - &related_port, - &username_fragment, - &tcp_type, - &vpn, - &network_adapter_type) + AttributeInit("transportId", &transport_id), + AttributeInit("isRemote", &is_remote), + AttributeInit("networkType", &network_type), + AttributeInit("ip", &ip), + AttributeInit("address", &address), + AttributeInit("port", &port), + AttributeInit("protocol", &protocol), + AttributeInit("relayProtocol", &relay_protocol), + AttributeInit("candidateType", &candidate_type), + AttributeInit("priority", &priority), + AttributeInit("url", &url), + AttributeInit("foundation", &foundation), + AttributeInit("relatedAddress", &related_address), + AttributeInit("relatedPort", &related_port), + AttributeInit("usernameFragment", &username_fragment), + AttributeInit("tcpType", &tcp_type), + AttributeInit("vpn", &vpn), + AttributeInit("networkAdapterType", &network_adapter_type)) // clang-format on RTCIceCandidateStats::RTCIceCandidateStats(std::string id, Timestamp timestamp, bool 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; + : RTCStats(std::move(id), timestamp), is_remote(is_remote) {} RTCIceCandidateStats::~RTCIceCandidateStats() {} @@ -228,286 +157,172 @@ const char* RTCRemoteIceCandidateStats::type() const { // clang-format off WEBRTC_RTCSTATS_IMPL(RTCPeerConnectionStats, RTCStats, "peer-connection", - &data_channels_opened, - &data_channels_closed) + AttributeInit("dataChannelsOpened", &data_channels_opened), + AttributeInit("dataChannelsClosed", &data_channels_closed)) // clang-format on RTCPeerConnectionStats::RTCPeerConnectionStats(std::string id, Timestamp timestamp) - : RTCStats(std::move(id), timestamp), - data_channels_opened("dataChannelsOpened"), - data_channels_closed("dataChannelsClosed") {} - -RTCPeerConnectionStats::RTCPeerConnectionStats( - const RTCPeerConnectionStats& other) = default; + : RTCStats(std::move(id), timestamp) {} RTCPeerConnectionStats::~RTCPeerConnectionStats() {} // clang-format off WEBRTC_RTCSTATS_IMPL(RTCRtpStreamStats, RTCStats, "rtp", - &ssrc, - &kind, - &transport_id, - &codec_id) + AttributeInit("ssrc", &ssrc), + AttributeInit("kind", &kind), + AttributeInit("transportId", &transport_id), + AttributeInit("codecId", &codec_id)) // clang-format on RTCRtpStreamStats::RTCRtpStreamStats(std::string id, Timestamp timestamp) - : RTCStats(std::move(id), timestamp), - ssrc("ssrc"), - kind("kind"), - transport_id("transportId"), - codec_id("codecId") {} - -RTCRtpStreamStats::RTCRtpStreamStats(const RTCRtpStreamStats& other) = default; + : RTCStats(std::move(id), timestamp) {} RTCRtpStreamStats::~RTCRtpStreamStats() {} // clang-format off WEBRTC_RTCSTATS_IMPL( RTCReceivedRtpStreamStats, RTCRtpStreamStats, "received-rtp", - &jitter, - &packets_lost) + AttributeInit("jitter", &jitter), + AttributeInit("packetsLost", &packets_lost)) // clang-format on RTCReceivedRtpStreamStats::RTCReceivedRtpStreamStats(std::string id, Timestamp timestamp) - : RTCRtpStreamStats(std::move(id), timestamp), - jitter("jitter"), - packets_lost("packetsLost") {} - -RTCReceivedRtpStreamStats::RTCReceivedRtpStreamStats( - const RTCReceivedRtpStreamStats& other) = default; + : RTCRtpStreamStats(std::move(id), timestamp) {} RTCReceivedRtpStreamStats::~RTCReceivedRtpStreamStats() {} // clang-format off -WEBRTC_RTCSTATS_IMPL( - RTCSentRtpStreamStats, RTCRtpStreamStats, "sent-rtp", - &packets_sent, - &bytes_sent) +WEBRTC_RTCSTATS_IMPL(RTCSentRtpStreamStats, RTCRtpStreamStats, "sent-rtp", + AttributeInit("packetsSent", &packets_sent), + AttributeInit("bytesSent", &bytes_sent)) // clang-format on RTCSentRtpStreamStats::RTCSentRtpStreamStats(std::string id, Timestamp timestamp) - : RTCRtpStreamStats(std::move(id), timestamp), - packets_sent("packetsSent"), - bytes_sent("bytesSent") {} - -RTCSentRtpStreamStats::RTCSentRtpStreamStats( - const RTCSentRtpStreamStats& other) = default; + : RTCRtpStreamStats(std::move(id), timestamp) {} RTCSentRtpStreamStats::~RTCSentRtpStreamStats() {} // clang-format off WEBRTC_RTCSTATS_IMPL( RTCInboundRtpStreamStats, RTCReceivedRtpStreamStats, "inbound-rtp", - &track_identifier, - &mid, - &remote_id, - &packets_received, - &packets_discarded, - &fec_packets_received, - &fec_bytes_received, - &fec_packets_discarded, - &fec_ssrc, - &bytes_received, - &header_bytes_received, - &retransmitted_packets_received, - &retransmitted_bytes_received, - &rtx_ssrc, - &last_packet_received_timestamp, - &jitter_buffer_delay, - &jitter_buffer_target_delay, - &jitter_buffer_minimum_delay, - &jitter_buffer_emitted_count, - &total_samples_received, - &concealed_samples, - &silent_concealed_samples, - &concealment_events, - &inserted_samples_for_deceleration, - &removed_samples_for_acceleration, - &audio_level, - &total_audio_energy, - &total_samples_duration, - &playout_id, - &frames_received, - &frame_width, - &frame_height, - &frames_per_second, - &frames_decoded, - &key_frames_decoded, - &frames_dropped, - &total_decode_time, - &total_processing_delay, - &total_assembly_time, - &frames_assembled_from_multiple_packets, - &total_inter_frame_delay, - &total_squared_inter_frame_delay, - &pause_count, - &total_pauses_duration, - &freeze_count, - &total_freezes_duration, - &content_type, - &estimated_playout_timestamp, - &decoder_implementation, - &fir_count, - &pli_count, - &nack_count, - &qp_sum, - &goog_timing_frame_info, - &power_efficient_decoder, - &jitter_buffer_flushes, - &delayed_packet_outage_samples, - &relative_packet_arrival_delay, - &interruption_count, - &total_interruption_duration, - &min_playout_delay) + AttributeInit("playoutId", &playout_id), + AttributeInit("trackIdentifier", &track_identifier), + AttributeInit("mid", &mid), + AttributeInit("remoteId", &remote_id), + AttributeInit("packetsReceived", &packets_received), + AttributeInit("packetsDiscarded", &packets_discarded), + AttributeInit("fecPacketsReceived", &fec_packets_received), + AttributeInit("fecBytesReceived", &fec_bytes_received), + AttributeInit("fecPacketsDiscarded", &fec_packets_discarded), + AttributeInit("fecSsrc", &fec_ssrc), + AttributeInit("bytesReceived", &bytes_received), + AttributeInit("headerBytesReceived", &header_bytes_received), + AttributeInit("retransmittedPacketsReceived", + &retransmitted_packets_received), + AttributeInit("retransmittedBytesReceived", &retransmitted_bytes_received), + AttributeInit("rtxSsrc", &rtx_ssrc), + AttributeInit("lastPacketReceivedTimestamp", + &last_packet_received_timestamp), + AttributeInit("jitterBufferDelay", &jitter_buffer_delay), + AttributeInit("jitterBufferTargetDelay", &jitter_buffer_target_delay), + AttributeInit("jitterBufferMinimumDelay", &jitter_buffer_minimum_delay), + AttributeInit("jitterBufferEmittedCount", &jitter_buffer_emitted_count), + AttributeInit("totalSamplesReceived", &total_samples_received), + AttributeInit("concealedSamples", &concealed_samples), + AttributeInit("silentConcealedSamples", &silent_concealed_samples), + AttributeInit("concealmentEvents", &concealment_events), + AttributeInit("insertedSamplesForDeceleration", + &inserted_samples_for_deceleration), + AttributeInit("removedSamplesForAcceleration", + &removed_samples_for_acceleration), + AttributeInit("audioLevel", &audio_level), + AttributeInit("totalAudioEnergy", &total_audio_energy), + AttributeInit("totalSamplesDuration", &total_samples_duration), + AttributeInit("framesReceived", &frames_received), + AttributeInit("frameWidth", &frame_width), + AttributeInit("frameHeight", &frame_height), + AttributeInit("framesPerSecond", &frames_per_second), + AttributeInit("framesDecoded", &frames_decoded), + AttributeInit("keyFramesDecoded", &key_frames_decoded), + AttributeInit("framesDropped", &frames_dropped), + AttributeInit("totalDecodeTime", &total_decode_time), + AttributeInit("totalProcessingDelay", &total_processing_delay), + AttributeInit("totalAssemblyTime", &total_assembly_time), + AttributeInit("framesAssembledFromMultiplePackets", + &frames_assembled_from_multiple_packets), + AttributeInit("totalInterFrameDelay", &total_inter_frame_delay), + AttributeInit("totalSquaredInterFrameDelay", + &total_squared_inter_frame_delay), + AttributeInit("pauseCount", &pause_count), + AttributeInit("totalPausesDuration", &total_pauses_duration), + AttributeInit("freezeCount", &freeze_count), + AttributeInit("totalFreezesDuration", &total_freezes_duration), + AttributeInit("contentType", &content_type), + AttributeInit("estimatedPlayoutTimestamp", &estimated_playout_timestamp), + AttributeInit("decoderImplementation", &decoder_implementation), + AttributeInit("firCount", &fir_count), + AttributeInit("pliCount", &pli_count), + AttributeInit("nackCount", &nack_count), + AttributeInit("qpSum", &qp_sum), + AttributeInit("googTimingFrameInfo", &goog_timing_frame_info), + AttributeInit("powerEfficientDecoder", &power_efficient_decoder), + 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 RTCInboundRtpStreamStats::RTCInboundRtpStreamStats(std::string id, Timestamp 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; + : RTCReceivedRtpStreamStats(std::move(id), timestamp) {} + RTCInboundRtpStreamStats::~RTCInboundRtpStreamStats() {} // clang-format off WEBRTC_RTCSTATS_IMPL( RTCOutboundRtpStreamStats, RTCSentRtpStreamStats, "outbound-rtp", - &media_source_id, - &remote_id, - &mid, - &rid, - &retransmitted_packets_sent, - &header_bytes_sent, - &retransmitted_bytes_sent, - &target_bitrate, - &frames_encoded, - &key_frames_encoded, - &total_encode_time, - &total_encoded_bytes_target, - &frame_width, - &frame_height, - &frames_per_second, - &frames_sent, - &huge_frames_sent, - &total_packet_send_delay, - &quality_limitation_reason, - &quality_limitation_durations, - &quality_limitation_resolution_changes, - &content_type, - &encoder_implementation, - &fir_count, - &pli_count, - &nack_count, - &qp_sum, - &active, - &power_efficient_encoder, - &scalability_mode, - &rtx_ssrc) + AttributeInit("mediaSourceId", &media_source_id), + AttributeInit("remoteId", &remote_id), + AttributeInit("mid", &mid), + AttributeInit("rid", &rid), + AttributeInit("retransmittedPacketsSent", &retransmitted_packets_sent), + AttributeInit("headerBytesSent", &header_bytes_sent), + AttributeInit("retransmittedBytesSent", &retransmitted_bytes_sent), + AttributeInit("targetBitrate", &target_bitrate), + AttributeInit("framesEncoded", &frames_encoded), + AttributeInit("keyFramesEncoded", &key_frames_encoded), + AttributeInit("totalEncodeTime", &total_encode_time), + AttributeInit("totalEncodedBytesTarget", &total_encoded_bytes_target), + AttributeInit("frameWidth", &frame_width), + AttributeInit("frameHeight", &frame_height), + AttributeInit("framesPerSecond", &frames_per_second), + AttributeInit("framesSent", &frames_sent), + AttributeInit("hugeFramesSent", &huge_frames_sent), + AttributeInit("totalPacketSendDelay", &total_packet_send_delay), + AttributeInit("qualityLimitationReason", &quality_limitation_reason), + AttributeInit("qualityLimitationDurations", &quality_limitation_durations), + AttributeInit("qualityLimitationResolutionChanges", + &quality_limitation_resolution_changes), + AttributeInit("contentType", &content_type), + AttributeInit("encoderImplementation", &encoder_implementation), + AttributeInit("firCount", &fir_count), + AttributeInit("pliCount", &pli_count), + AttributeInit("nackCount", &nack_count), + AttributeInit("qpSum", &qp_sum), + AttributeInit("active", &active), + AttributeInit("powerEfficientEncoder", &power_efficient_encoder), + AttributeInit("scalabilityMode", &scalability_mode), + AttributeInit("rtxSsrc", &rtx_ssrc)) // clang-format on RTCOutboundRtpStreamStats::RTCOutboundRtpStreamStats(std::string id, Timestamp 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; + : RTCSentRtpStreamStats(std::move(id), timestamp) {} RTCOutboundRtpStreamStats::~RTCOutboundRtpStreamStats() {} @@ -515,25 +330,17 @@ RTCOutboundRtpStreamStats::~RTCOutboundRtpStreamStats() {} WEBRTC_RTCSTATS_IMPL( RTCRemoteInboundRtpStreamStats, RTCReceivedRtpStreamStats, "remote-inbound-rtp", - &local_id, - &round_trip_time, - &fraction_lost, - &total_round_trip_time, - &round_trip_time_measurements) + AttributeInit("localId", &local_id), + AttributeInit("roundTripTime", &round_trip_time), + AttributeInit("fractionLost", &fraction_lost), + AttributeInit("totalRoundTripTime", &total_round_trip_time), + AttributeInit("roundTripTimeMeasurements", &round_trip_time_measurements)) // clang-format on RTCRemoteInboundRtpStreamStats::RTCRemoteInboundRtpStreamStats( std::string id, Timestamp 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; + : RTCReceivedRtpStreamStats(std::move(id), timestamp) {} RTCRemoteInboundRtpStreamStats::~RTCRemoteInboundRtpStreamStats() {} @@ -541,156 +348,100 @@ RTCRemoteInboundRtpStreamStats::~RTCRemoteInboundRtpStreamStats() {} WEBRTC_RTCSTATS_IMPL( RTCRemoteOutboundRtpStreamStats, RTCSentRtpStreamStats, "remote-outbound-rtp", - &local_id, - &remote_timestamp, - &reports_sent, - &round_trip_time, - &round_trip_time_measurements, - &total_round_trip_time) + AttributeInit("localId", &local_id), + AttributeInit("remoteTimestamp", &remote_timestamp), + AttributeInit("reportsSent", &reports_sent), + AttributeInit("roundTripTime", &round_trip_time), + AttributeInit("roundTripTimeMeasurements", &round_trip_time_measurements), + AttributeInit("totalRoundTripTime", &total_round_trip_time)) // clang-format on RTCRemoteOutboundRtpStreamStats::RTCRemoteOutboundRtpStreamStats( std::string id, Timestamp 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; + : RTCSentRtpStreamStats(std::move(id), timestamp) {} RTCRemoteOutboundRtpStreamStats::~RTCRemoteOutboundRtpStreamStats() {} // clang-format off WEBRTC_RTCSTATS_IMPL(RTCMediaSourceStats, RTCStats, "parent-media-source", - &track_identifier, - &kind) + AttributeInit("trackIdentifier", &track_identifier), + AttributeInit("kind", &kind)) // clang-format on RTCMediaSourceStats::RTCMediaSourceStats(std::string id, Timestamp timestamp) - : RTCStats(std::move(id), timestamp), - track_identifier("trackIdentifier"), - kind("kind") {} - -RTCMediaSourceStats::RTCMediaSourceStats(const RTCMediaSourceStats& other) = - default; + : RTCStats(std::move(id), timestamp) {} RTCMediaSourceStats::~RTCMediaSourceStats() {} // clang-format off WEBRTC_RTCSTATS_IMPL(RTCAudioSourceStats, RTCMediaSourceStats, "media-source", - &audio_level, - &total_audio_energy, - &total_samples_duration, - &echo_return_loss, - &echo_return_loss_enhancement) + AttributeInit("audioLevel", &audio_level), + AttributeInit("totalAudioEnergy", &total_audio_energy), + AttributeInit("totalSamplesDuration", &total_samples_duration), + AttributeInit("echoReturnLoss", &echo_return_loss), + AttributeInit("echoReturnLossEnhancement", &echo_return_loss_enhancement)) // clang-format on RTCAudioSourceStats::RTCAudioSourceStats(std::string id, Timestamp 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; + : RTCMediaSourceStats(std::move(id), timestamp) {} RTCAudioSourceStats::~RTCAudioSourceStats() {} // clang-format off WEBRTC_RTCSTATS_IMPL(RTCVideoSourceStats, RTCMediaSourceStats, "media-source", - &width, - &height, - &frames, - &frames_per_second) + AttributeInit("width", &width), + AttributeInit("height", &height), + AttributeInit("frames", &frames), + AttributeInit("framesPerSecond", &frames_per_second)) // clang-format on RTCVideoSourceStats::RTCVideoSourceStats(std::string id, Timestamp timestamp) - : RTCMediaSourceStats(std::move(id), timestamp), - width("width"), - height("height"), - frames("frames"), - frames_per_second("framesPerSecond") {} - -RTCVideoSourceStats::RTCVideoSourceStats(const RTCVideoSourceStats& other) = - default; + : RTCMediaSourceStats(std::move(id), timestamp) {} RTCVideoSourceStats::~RTCVideoSourceStats() {} // clang-format off WEBRTC_RTCSTATS_IMPL(RTCTransportStats, RTCStats, "transport", - &bytes_sent, - &packets_sent, - &bytes_received, - &packets_received, - &rtcp_transport_stats_id, - &dtls_state, - &selected_candidate_pair_id, - &local_certificate_id, - &remote_certificate_id, - &tls_version, - &dtls_cipher, - &dtls_role, - &srtp_cipher, - &selected_candidate_pair_changes, - &ice_role, - &ice_local_username_fragment, - &ice_state) + AttributeInit("bytesSent", &bytes_sent), + AttributeInit("packetsSent", &packets_sent), + AttributeInit("bytesReceived", &bytes_received), + AttributeInit("packetsReceived", &packets_received), + AttributeInit("rtcpTransportStatsId", &rtcp_transport_stats_id), + AttributeInit("dtlsState", &dtls_state), + AttributeInit("selectedCandidatePairId", &selected_candidate_pair_id), + AttributeInit("localCertificateId", &local_certificate_id), + AttributeInit("remoteCertificateId", &remote_certificate_id), + AttributeInit("tlsVersion", &tls_version), + AttributeInit("dtlsCipher", &dtls_cipher), + AttributeInit("dtlsRole", &dtls_role), + AttributeInit("srtpCipher", &srtp_cipher), + AttributeInit("selectedCandidatePairChanges", + &selected_candidate_pair_changes), + AttributeInit("iceRole", &ice_role), + AttributeInit("iceLocalUsernameFragment", &ice_local_username_fragment), + AttributeInit("iceState", &ice_state)) // clang-format on RTCTransportStats::RTCTransportStats(std::string id, Timestamp 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; + : RTCStats(std::move(id), timestamp) {} 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, Timestamp timestamp) - : 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; + : RTCStats(std::move(id), timestamp), kind("audio") {} 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 diff --git a/third_party/libwebrtc/stats/test/rtc_test_stats.cc b/third_party/libwebrtc/stats/test/rtc_test_stats.cc index a83fa24178..834daeef72 100644 --- a/third_party/libwebrtc/stats/test/rtc_test_stats.cc +++ b/third_party/libwebrtc/stats/test/rtc_test_stats.cc @@ -10,6 +10,7 @@ #include "stats/test/rtc_test_stats.h" +#include "api/stats/attribute.h" #include "rtc_base/checks.h" namespace webrtc { @@ -17,60 +18,25 @@ namespace webrtc { WEBRTC_RTCSTATS_IMPL(RTCTestStats, RTCStats, "test-stats", - &m_bool, - &m_int32, - &m_uint32, - &m_int64, - &m_uint64, - &m_double, - &m_string, - &m_sequence_bool, - &m_sequence_int32, - &m_sequence_uint32, - &m_sequence_int64, - &m_sequence_uint64, - &m_sequence_double, - &m_sequence_string, - &m_map_string_uint64, - &m_map_string_double) + AttributeInit("mBool", &m_bool), + AttributeInit("mInt32", &m_int32), + AttributeInit("mUint32", &m_uint32), + AttributeInit("mInt64", &m_int64), + AttributeInit("mUint64", &m_uint64), + AttributeInit("mDouble", &m_double), + AttributeInit("mString", &m_string), + AttributeInit("mSequenceBool", &m_sequence_bool), + AttributeInit("mSequenceInt32", &m_sequence_int32), + AttributeInit("mSequenceUint32", &m_sequence_uint32), + AttributeInit("mSequenceInt64", &m_sequence_int64), + AttributeInit("mSequenceUint64", &m_sequence_uint64), + AttributeInit("mSequenceDouble", &m_sequence_double), + AttributeInit("mSequenceString", &m_sequence_string), + AttributeInit("mMapStringUint64", &m_map_string_uint64), + AttributeInit("mMapStringDouble", &m_map_string_double)) RTCTestStats::RTCTestStats(const std::string& id, Timestamp 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) {} + : RTCStats(id, timestamp) {} RTCTestStats::~RTCTestStats() {} diff --git a/third_party/libwebrtc/stats/test/rtc_test_stats.h b/third_party/libwebrtc/stats/test/rtc_test_stats.h index 0247c0cc01..05c0904c02 100644 --- a/third_party/libwebrtc/stats/test/rtc_test_stats.h +++ b/third_party/libwebrtc/stats/test/rtc_test_stats.h @@ -24,9 +24,7 @@ namespace webrtc { class RTC_EXPORT RTCTestStats : public RTCStats { public: WEBRTC_RTCSTATS_DECL(); - RTCTestStats(const std::string& id, Timestamp timestamp); - RTCTestStats(const RTCTestStats& other); ~RTCTestStats() override; RTCStatsMember m_bool; -- cgit v1.2.3