summaryrefslogtreecommitdiffstats
path: root/third_party/libwebrtc/api/stats
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 17:32:43 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 17:32:43 +0000
commit6bf0a5cb5034a7e684dcc3500e841785237ce2dd (patch)
treea68f146d7fa01f0134297619fbe7e33db084e0aa /third_party/libwebrtc/api/stats
parentInitial commit. (diff)
downloadthunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.tar.xz
thunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.zip
Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/libwebrtc/api/stats')
-rw-r--r--third_party/libwebrtc/api/stats/OWNERS2
-rw-r--r--third_party/libwebrtc/api/stats/rtc_stats.h580
-rw-r--r--third_party/libwebrtc/api/stats/rtc_stats_collector_callback.h30
-rw-r--r--third_party/libwebrtc/api/stats/rtc_stats_report.h144
-rw-r--r--third_party/libwebrtc/api/stats/rtcstats_objects.h722
5 files changed, 1478 insertions, 0 deletions
diff --git a/third_party/libwebrtc/api/stats/OWNERS b/third_party/libwebrtc/api/stats/OWNERS
new file mode 100644
index 0000000000..7e98070d5d
--- /dev/null
+++ b/third_party/libwebrtc/api/stats/OWNERS
@@ -0,0 +1,2 @@
+hbos@webrtc.org
+hta@webrtc.org
diff --git a/third_party/libwebrtc/api/stats/rtc_stats.h b/third_party/libwebrtc/api/stats/rtc_stats.h
new file mode 100644
index 0000000000..72775243c7
--- /dev/null
+++ b/third_party/libwebrtc/api/stats/rtc_stats.h
@@ -0,0 +1,580 @@
+/*
+ * Copyright 2016 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.
+ */
+
+#ifndef API_STATS_RTC_STATS_H_
+#define API_STATS_RTC_STATS_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/types/optional.h"
+#include "api/units/timestamp.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/system/rtc_export.h"
+#include "rtc_base/system/rtc_export_template.h"
+
+namespace webrtc {
+
+class RTCStatsMemberInterface;
+
+// Abstract base class for RTCStats-derived dictionaries, see
+// https://w3c.github.io/webrtc-stats/.
+//
+// All derived classes must have the following static variable defined:
+// static const char kType[];
+// It is used as a unique class identifier and a string representation of the
+// class type, see https://w3c.github.io/webrtc-stats/#rtcstatstype-str*.
+// Use the `WEBRTC_RTCSTATS_IMPL` macro when implementing subclasses, see macro
+// for details.
+//
+// Derived classes list their dictionary members, RTCStatsMember<T>, as public
+// fields, allowing the following:
+//
+// RTCFooStats foo("fooId", Timestamp::Micros(GetCurrentTime()));
+// foo.bar = 42;
+// foo.baz = std::vector<std::string>();
+// foo.baz->push_back("hello world");
+// uint32_t x = *foo.bar;
+//
+// Pointers to all the members are available with `Members`, allowing iteration:
+//
+// for (const RTCStatsMemberInterface* member : foo.Members()) {
+// printf("%s = %s\n", member->name(), member->ValueToString().c_str());
+// }
+class RTC_EXPORT RTCStats {
+ public:
+ RTCStats(const std::string& id, Timestamp timestamp)
+ : id_(id), timestamp_(timestamp) {}
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCStats(std::string id, int64_t timestamp_us)
+ : RTCStats(std::move(id), Timestamp::Micros(timestamp_us)) {}
+
+ virtual ~RTCStats() {}
+
+ virtual std::unique_ptr<RTCStats> copy() const = 0;
+
+ const std::string& id() const { return id_; }
+ // Time relative to the UNIX epoch (Jan 1, 1970, UTC), in microseconds.
+ ABSL_DEPRECATED("Use .timestamp().us() instead")
+ int64_t timestamp_us() const { return timestamp_.us(); }
+ Timestamp timestamp() const { return timestamp_; }
+
+ // Returns the static member variable `kType` of the implementing class.
+ virtual const char* type() const = 0;
+ // Returns a vector of pointers to all the `RTCStatsMemberInterface` members
+ // of this class. This allows for iteration of members. For a given class,
+ // `Members` always returns the same members in the same order.
+ std::vector<const RTCStatsMemberInterface*> Members() const;
+ // Checks if the two stats objects are of the same type and have the same
+ // member values. Timestamps are not compared. These operators are exposed for
+ // testing.
+ bool operator==(const RTCStats& other) const;
+ bool operator!=(const RTCStats& other) const;
+
+ // Creates a JSON readable string representation of the stats
+ // object, listing all of its members (names and values).
+ std::string ToJson() const;
+
+ // Downcasts the stats object to an `RTCStats` subclass `T`. DCHECKs that the
+ // object is of type `T`.
+ template <typename T>
+ const T& cast_to() const {
+ RTC_DCHECK_EQ(type(), T::kType);
+ return static_cast<const T&>(*this);
+ }
+
+ protected:
+ // Gets a vector of all members of this `RTCStats` object, including members
+ // derived from parent classes. `additional_capacity` is how many more members
+ // shall be reserved in the vector (so that subclasses can allocate a vector
+ // with room for both parent and child members without it having to resize).
+ virtual std::vector<const RTCStatsMemberInterface*>
+ MembersOfThisObjectAndAncestors(size_t additional_capacity) const;
+
+ std::string const id_;
+ Timestamp timestamp_;
+};
+
+// All `RTCStats` classes should use these macros.
+// `WEBRTC_RTCSTATS_DECL` is placed in a public section of the class definition.
+// `WEBRTC_RTCSTATS_IMPL` is placed outside the class definition (in a .cc).
+//
+// These macros declare (in _DECL) and define (in _IMPL) the static `kType` and
+// overrides methods as required by subclasses of `RTCStats`: `copy`, `type` and
+// `MembersOfThisObjectAndAncestors`. The |...| argument is a list of addresses
+// to each member defined in the implementing class. The list must have at least
+// one member.
+//
+// (Since class names need to be known to implement these methods this cannot be
+// part of the base `RTCStats`. While these methods could be implemented using
+// templates, that would only work for immediate subclasses. Subclasses of
+// subclasses also have to override these methods, resulting in boilerplate
+// code. Using a macro avoids this and works for any `RTCStats` class, including
+// grandchildren.)
+//
+// Sample usage:
+//
+// rtcfoostats.h:
+// class RTCFooStats : public RTCStats {
+// public:
+// WEBRTC_RTCSTATS_DECL();
+//
+// RTCFooStats(const std::string& id, int64_t timestamp_us);
+//
+// RTCStatsMember<int32_t> foo;
+// RTCStatsMember<int32_t> bar;
+// };
+//
+// rtcfoostats.cc:
+// WEBRTC_RTCSTATS_IMPL(RTCFooStats, RTCStats, "foo-stats"
+// &foo,
+// &bar);
+//
+// RTCFooStats::RTCFooStats(const std::string& id, int64_t timestamp_us)
+// : RTCStats(id, timestamp_us),
+// foo("foo"),
+// bar("bar") {
+// }
+//
+#define WEBRTC_RTCSTATS_DECL() \
+ protected: \
+ std::vector<const webrtc::RTCStatsMemberInterface*> \
+ MembersOfThisObjectAndAncestors(size_t local_var_additional_capacity) \
+ const override; \
+ \
+ public: \
+ static const char kType[]; \
+ \
+ std::unique_ptr<webrtc::RTCStats> copy() const override; \
+ const char* type() const override
+
+#define WEBRTC_RTCSTATS_IMPL(this_class, parent_class, type_str, ...) \
+ const char this_class::kType[] = type_str; \
+ \
+ std::unique_ptr<webrtc::RTCStats> this_class::copy() const { \
+ return std::make_unique<this_class>(*this); \
+ } \
+ \
+ const char* this_class::type() const { return this_class::kType; } \
+ \
+ std::vector<const webrtc::RTCStatsMemberInterface*> \
+ this_class::MembersOfThisObjectAndAncestors( \
+ size_t local_var_additional_capacity) const { \
+ const webrtc::RTCStatsMemberInterface* local_var_members[] = { \
+ __VA_ARGS__}; \
+ size_t local_var_members_count = \
+ sizeof(local_var_members) / sizeof(local_var_members[0]); \
+ std::vector<const webrtc::RTCStatsMemberInterface*> \
+ local_var_members_vec = parent_class::MembersOfThisObjectAndAncestors( \
+ local_var_members_count + local_var_additional_capacity); \
+ RTC_DCHECK_GE( \
+ local_var_members_vec.capacity() - local_var_members_vec.size(), \
+ local_var_members_count + local_var_additional_capacity); \
+ local_var_members_vec.insert(local_var_members_vec.end(), \
+ &local_var_members[0], \
+ &local_var_members[local_var_members_count]); \
+ return local_var_members_vec; \
+ }
+
+// A version of WEBRTC_RTCSTATS_IMPL() where "..." is omitted, used to avoid a
+// compile error on windows. This is used if the stats dictionary does not
+// declare any members of its own (but perhaps its parent dictionary does).
+#define WEBRTC_RTCSTATS_IMPL_NO_MEMBERS(this_class, parent_class, type_str) \
+ const char this_class::kType[] = type_str; \
+ \
+ std::unique_ptr<webrtc::RTCStats> this_class::copy() const { \
+ return std::make_unique<this_class>(*this); \
+ } \
+ \
+ const char* this_class::type() const { return this_class::kType; } \
+ \
+ std::vector<const webrtc::RTCStatsMemberInterface*> \
+ this_class::MembersOfThisObjectAndAncestors( \
+ size_t local_var_additional_capacity) const { \
+ return parent_class::MembersOfThisObjectAndAncestors(0); \
+ }
+
+// Non-standard stats members can be exposed to the JavaScript API in Chrome
+// e.g. through origin trials. The group ID can be used by the blink layer to
+// determine if a stats member should be exposed or not. Multiple non-standard
+// stats members can share the same group ID so that they are exposed together.
+enum class NonStandardGroupId {
+ // Group ID used for testing purposes only.
+ kGroupIdForTesting,
+ // I2E:
+ // https://groups.google.com/a/chromium.org/forum/#!topic/blink-dev/hE2B1iItPDk
+ kRtcAudioJitterBufferMaxPackets,
+ // I2E:
+ // https://groups.google.com/a/chromium.org/forum/#!topic/blink-dev/YbhMyqLXXXo
+ kRtcStatsRelativePacketArrivalDelay,
+};
+
+// Certain stat members should only be exposed to the JavaScript API in
+// certain circumstances as to avoid passive fingerprinting.
+enum class StatExposureCriteria : uint8_t {
+ // The stat should always be exposed. This is the default.
+ kAlways,
+ // The stat exposes hardware capabilities and thus should has limited exposure
+ // to JavaScript. The requirements for exposure are written in the spec at
+ // https://w3c.github.io/webrtc-stats/#limiting-exposure-of-hardware-capabilities.
+ kHardwareCapability,
+ // The stat is non-standard so user agents should filter these.
+ kNonStandard,
+};
+
+// Interface for `RTCStats` members, which have a name and a value of a type
+// defined in a subclass. Only the types listed in `Type` are supported, these
+// are implemented by `RTCStatsMember<T>`. The value of a member may be
+// undefined, the value can only be read if `is_defined`.
+class RTCStatsMemberInterface {
+ public:
+ // Member value types.
+ enum Type {
+ kBool, // bool
+ kInt32, // int32_t
+ kUint32, // uint32_t
+ kInt64, // int64_t
+ kUint64, // uint64_t
+ kDouble, // double
+ kString, // std::string
+
+ kSequenceBool, // std::vector<bool>
+ kSequenceInt32, // std::vector<int32_t>
+ kSequenceUint32, // std::vector<uint32_t>
+ kSequenceInt64, // std::vector<int64_t>
+ kSequenceUint64, // std::vector<uint64_t>
+ kSequenceDouble, // std::vector<double>
+ kSequenceString, // std::vector<std::string>
+
+ kMapStringUint64, // std::map<std::string, uint64_t>
+ kMapStringDouble, // std::map<std::string, double>
+ };
+
+ virtual ~RTCStatsMemberInterface() {}
+
+ const char* name() const { return name_; }
+ virtual Type type() const = 0;
+ virtual bool is_sequence() const = 0;
+ virtual bool is_string() const = 0;
+ virtual bool is_defined() const = 0;
+ // Is this part of the stats spec? Used so that chromium can easily filter
+ // out anything unstandardized.
+ bool is_standardized() const {
+ return exposure_criteria() != StatExposureCriteria::kNonStandard;
+ }
+ // Non-standard stats members can have group IDs in order to be exposed in
+ // JavaScript through experiments. Standardized stats have no group IDs.
+ virtual std::vector<NonStandardGroupId> group_ids() const { return {}; }
+ // The conditions for exposing the statistic to JavaScript. Stats with
+ // criteria that is not kAlways has some restriction and should be filtered
+ // in accordance to the spec.
+ virtual StatExposureCriteria exposure_criteria() const {
+ return StatExposureCriteria::kAlways;
+ }
+ // Type and value comparator. The names are not compared. These operators are
+ // exposed for testing.
+ bool operator==(const RTCStatsMemberInterface& other) const {
+ return IsEqual(other);
+ }
+ bool operator!=(const RTCStatsMemberInterface& other) const {
+ return !(*this == other);
+ }
+ virtual std::string ValueToString() const = 0;
+ // This is the same as ValueToString except for kInt64 and kUint64 types,
+ // where the value is represented as a double instead of as an integer.
+ // Since JSON stores numbers as floating point numbers, very large integers
+ // cannot be accurately represented, so we prefer to display them as doubles
+ // instead.
+ virtual std::string ValueToJson() const = 0;
+
+ template <typename T>
+ const T& cast_to() const {
+ RTC_DCHECK_EQ(type(), T::StaticType());
+ return static_cast<const T&>(*this);
+ }
+
+ protected:
+ explicit RTCStatsMemberInterface(const char* name) : name_(name) {}
+
+ virtual bool IsEqual(const RTCStatsMemberInterface& other) const = 0;
+
+ const char* const name_;
+};
+
+// Template implementation of `RTCStatsMemberInterface`.
+// The supported types are the ones described by
+// `RTCStatsMemberInterface::Type`.
+template <typename T>
+class RTCStatsMember : public RTCStatsMemberInterface {
+ public:
+ explicit RTCStatsMember(const char* name)
+ : 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();
+ Type type() const override { return StaticType(); }
+ bool is_sequence() const override;
+ bool is_string() const override;
+ bool is_defined() const override { return value_.has_value(); }
+ std::string ValueToString() const override;
+ std::string ValueToJson() const override;
+
+ template <typename U>
+ inline T ValueOrDefault(U default_value) const {
+ return value_.value_or(default_value);
+ }
+
+ // Assignment operators.
+ T& operator=(const T& value) {
+ value_ = value;
+ return value_.value();
+ }
+ T& operator=(const T&& value) {
+ value_ = std::move(value);
+ return value_.value();
+ }
+
+ // Value getters.
+ T& operator*() {
+ RTC_DCHECK(value_);
+ return *value_;
+ }
+ const T& operator*() const {
+ RTC_DCHECK(value_);
+ return *value_;
+ }
+
+ // Value getters, arrow operator.
+ T* operator->() {
+ RTC_DCHECK(value_);
+ return &(*value_);
+ }
+ const T* operator->() const {
+ RTC_DCHECK(value_);
+ return &(*value_);
+ }
+
+ protected:
+ bool IsEqual(const RTCStatsMemberInterface& other) const override {
+ if (type() != other.type() ||
+ is_standardized() != other.is_standardized() ||
+ exposure_criteria() != other.exposure_criteria())
+ return false;
+ const RTCStatsMember<T>& other_t =
+ static_cast<const RTCStatsMember<T>&>(other);
+ return value_ == other_t.value_;
+ }
+
+ private:
+ absl::optional<T> value_;
+};
+
+namespace rtc_stats_internal {
+
+typedef std::map<std::string, uint64_t> MapStringUint64;
+typedef std::map<std::string, double> MapStringDouble;
+
+} // namespace rtc_stats_internal
+
+#define WEBRTC_DECLARE_RTCSTATSMEMBER(T) \
+ template <> \
+ RTC_EXPORT RTCStatsMemberInterface::Type RTCStatsMember<T>::StaticType(); \
+ template <> \
+ RTC_EXPORT bool RTCStatsMember<T>::is_sequence() const; \
+ template <> \
+ RTC_EXPORT bool RTCStatsMember<T>::is_string() const; \
+ template <> \
+ RTC_EXPORT std::string RTCStatsMember<T>::ValueToString() const; \
+ template <> \
+ RTC_EXPORT std::string RTCStatsMember<T>::ValueToJson() const; \
+ extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT) \
+ RTCStatsMember<T>
+
+WEBRTC_DECLARE_RTCSTATSMEMBER(bool);
+WEBRTC_DECLARE_RTCSTATSMEMBER(int32_t);
+WEBRTC_DECLARE_RTCSTATSMEMBER(uint32_t);
+WEBRTC_DECLARE_RTCSTATSMEMBER(int64_t);
+WEBRTC_DECLARE_RTCSTATSMEMBER(uint64_t);
+WEBRTC_DECLARE_RTCSTATSMEMBER(double);
+WEBRTC_DECLARE_RTCSTATSMEMBER(std::string);
+WEBRTC_DECLARE_RTCSTATSMEMBER(std::vector<bool>);
+WEBRTC_DECLARE_RTCSTATSMEMBER(std::vector<int32_t>);
+WEBRTC_DECLARE_RTCSTATSMEMBER(std::vector<uint32_t>);
+WEBRTC_DECLARE_RTCSTATSMEMBER(std::vector<int64_t>);
+WEBRTC_DECLARE_RTCSTATSMEMBER(std::vector<uint64_t>);
+WEBRTC_DECLARE_RTCSTATSMEMBER(std::vector<double>);
+WEBRTC_DECLARE_RTCSTATSMEMBER(std::vector<std::string>);
+WEBRTC_DECLARE_RTCSTATSMEMBER(rtc_stats_internal::MapStringUint64);
+WEBRTC_DECLARE_RTCSTATSMEMBER(rtc_stats_internal::MapStringDouble);
+
+// For stats with restricted exposure.
+template <typename T, StatExposureCriteria E>
+class RTCRestrictedStatsMember : public RTCStatsMember<T> {
+ public:
+ explicit RTCRestrictedStatsMember(const char* name)
+ : RTCStatsMember<T>(name) {}
+ RTCRestrictedStatsMember(const char* name, const T& value)
+ : RTCStatsMember<T>(name, value) {}
+ RTCRestrictedStatsMember(const char* name, T&& value)
+ : RTCStatsMember<T>(name, std::move(value)) {}
+ RTCRestrictedStatsMember(const RTCRestrictedStatsMember<T, E>& other)
+ : RTCStatsMember<T>(other) {}
+ RTCRestrictedStatsMember(RTCRestrictedStatsMember<T, E>&& other)
+ : RTCStatsMember<T>(std::move(other)) {}
+
+ StatExposureCriteria exposure_criteria() const override { return E; }
+
+ T& operator=(const T& value) { return RTCStatsMember<T>::operator=(value); }
+ T& operator=(const T&& value) {
+ return RTCStatsMember<T>::operator=(std::move(value));
+ }
+
+ private:
+ static_assert(E != StatExposureCriteria::kAlways,
+ "kAlways is the default exposure criteria. Use "
+ "RTCStatMember<T> instead.");
+};
+
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<bool, StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<int32_t,
+ StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<uint32_t,
+ StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<int64_t,
+ StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<uint64_t,
+ StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<double, StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<std::string,
+ StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<std::vector<bool>,
+ StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<std::vector<int32_t>,
+ StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<std::vector<uint32_t>,
+ StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<std::vector<int64_t>,
+ StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<std::vector<uint64_t>,
+ StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<std::vector<double>,
+ StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<std::vector<std::string>,
+ StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<std::map<std::string, uint64_t>,
+ StatExposureCriteria::kHardwareCapability>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCRestrictedStatsMember<std::map<std::string, double>,
+ StatExposureCriteria::kHardwareCapability>;
+
+// Using inheritance just so that it's obvious from the member's declaration
+// whether it's standardized or not.
+template <typename T>
+class RTCNonStandardStatsMember
+ : public RTCRestrictedStatsMember<T, StatExposureCriteria::kNonStandard> {
+ public:
+ explicit RTCNonStandardStatsMember(const char* name)
+ : RTCRestrictedStatsBase(name) {}
+ RTCNonStandardStatsMember(const char* name,
+ std::initializer_list<NonStandardGroupId> group_ids)
+ : RTCRestrictedStatsBase(name), group_ids_(group_ids) {}
+ RTCNonStandardStatsMember(const char* name, const T& value)
+ : RTCRestrictedStatsBase(name, value) {}
+ RTCNonStandardStatsMember(const char* name, T&& value)
+ : RTCRestrictedStatsBase(name, std::move(value)) {}
+ RTCNonStandardStatsMember(const RTCNonStandardStatsMember<T>& other)
+ : RTCRestrictedStatsBase(other), group_ids_(other.group_ids_) {}
+ RTCNonStandardStatsMember(RTCNonStandardStatsMember<T>&& other)
+ : RTCRestrictedStatsBase(std::move(other)),
+ group_ids_(std::move(other.group_ids_)) {}
+
+ std::vector<NonStandardGroupId> group_ids() const override {
+ return group_ids_;
+ }
+
+ T& operator=(const T& value) {
+ return RTCRestrictedStatsMember<
+ T, StatExposureCriteria::kNonStandard>::operator=(value);
+ }
+ T& operator=(const T&& value) {
+ return RTCRestrictedStatsMember<
+ T, StatExposureCriteria::kNonStandard>::operator=(std::move(value));
+ }
+
+ private:
+ using RTCRestrictedStatsBase =
+ RTCRestrictedStatsMember<T, StatExposureCriteria::kNonStandard>;
+ std::vector<NonStandardGroupId> group_ids_;
+};
+
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<bool>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<int32_t>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<uint32_t>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<int64_t>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<uint64_t>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<double>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<std::string>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<std::vector<bool>>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<std::vector<int32_t>>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<std::vector<uint32_t>>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<std::vector<int64_t>>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<std::vector<uint64_t>>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<std::vector<double>>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<std::vector<std::string>>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<std::map<std::string, uint64_t>>;
+extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT)
+ RTCNonStandardStatsMember<std::map<std::string, double>>;
+
+} // namespace webrtc
+
+#endif // API_STATS_RTC_STATS_H_
diff --git a/third_party/libwebrtc/api/stats/rtc_stats_collector_callback.h b/third_party/libwebrtc/api/stats/rtc_stats_collector_callback.h
new file mode 100644
index 0000000000..506cc63e6f
--- /dev/null
+++ b/third_party/libwebrtc/api/stats/rtc_stats_collector_callback.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2016 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.
+ */
+
+#ifndef API_STATS_RTC_STATS_COLLECTOR_CALLBACK_H_
+#define API_STATS_RTC_STATS_COLLECTOR_CALLBACK_H_
+
+#include "api/scoped_refptr.h"
+#include "api/stats/rtc_stats_report.h"
+#include "rtc_base/ref_count.h"
+
+namespace webrtc {
+
+class RTCStatsCollectorCallback : public rtc::RefCountInterface {
+ public:
+ ~RTCStatsCollectorCallback() override = default;
+
+ virtual void OnStatsDelivered(
+ const rtc::scoped_refptr<const RTCStatsReport>& report) = 0;
+};
+
+} // namespace webrtc
+
+#endif // API_STATS_RTC_STATS_COLLECTOR_CALLBACK_H_
diff --git a/third_party/libwebrtc/api/stats/rtc_stats_report.h b/third_party/libwebrtc/api/stats/rtc_stats_report.h
new file mode 100644
index 0000000000..1cc6293fec
--- /dev/null
+++ b/third_party/libwebrtc/api/stats/rtc_stats_report.h
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2016 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.
+ */
+
+#ifndef API_STATS_RTC_STATS_REPORT_H_
+#define API_STATS_RTC_STATS_REPORT_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "api/ref_counted_base.h"
+#include "api/scoped_refptr.h"
+#include "api/stats/rtc_stats.h"
+#include "api/units/timestamp.h"
+// TODO(tommi): Remove this include after fixing iwyu issue in chromium.
+// See: third_party/blink/renderer/platform/peerconnection/rtc_stats.cc
+#include "rtc_base/ref_counted_object.h"
+#include "rtc_base/system/rtc_export.h"
+
+namespace webrtc {
+
+// A collection of stats.
+// This is accessible as a map from `RTCStats::id` to `RTCStats`.
+class RTC_EXPORT RTCStatsReport final
+ : public rtc::RefCountedNonVirtual<RTCStatsReport> {
+ public:
+ typedef std::map<std::string, std::unique_ptr<const RTCStats>> StatsMap;
+
+ class RTC_EXPORT ConstIterator {
+ public:
+ ConstIterator(ConstIterator&& other);
+ ~ConstIterator();
+
+ ConstIterator& operator++();
+ ConstIterator& operator++(int);
+ const RTCStats& operator*() const;
+ const RTCStats* operator->() const;
+ bool operator==(const ConstIterator& other) const;
+ bool operator!=(const ConstIterator& other) const;
+
+ private:
+ friend class RTCStatsReport;
+ ConstIterator(const rtc::scoped_refptr<const RTCStatsReport>& report,
+ StatsMap::const_iterator it);
+
+ // Reference report to make sure it is kept alive.
+ rtc::scoped_refptr<const RTCStatsReport> report_;
+ StatsMap::const_iterator it_;
+ };
+
+ // TODO(bugs.webrtc.org/13756): deprecate this in favor of Timestamp.
+ // TODO(hbos): Remove "= 0" once downstream has been updated to call with a
+ // parameter.
+ static rtc::scoped_refptr<RTCStatsReport> Create(int64_t timestamp_us = 0);
+ static rtc::scoped_refptr<RTCStatsReport> Create(Timestamp timestamp);
+
+ // TODO(bugs.webrtc.org/13756): deprecate this in favor of Timestamp.
+ explicit RTCStatsReport(int64_t timestamp_us);
+ explicit RTCStatsReport(Timestamp timestamp);
+
+ RTCStatsReport(const RTCStatsReport& other) = delete;
+ rtc::scoped_refptr<RTCStatsReport> Copy() const;
+
+ int64_t timestamp_us() const { return timestamp_.us_or(-1); }
+ Timestamp timestamp() const { return timestamp_; }
+ void AddStats(std::unique_ptr<const RTCStats> stats);
+ // On success, returns a non-owning pointer to `stats`. If the stats ID is not
+ // unique, `stats` is not inserted and nullptr is returned.
+ template <typename T>
+ T* TryAddStats(std::unique_ptr<T> stats) {
+ T* stats_ptr = stats.get();
+ if (!stats_
+ .insert(std::make_pair(std::string(stats->id()), std::move(stats)))
+ .second) {
+ return nullptr;
+ }
+ return stats_ptr;
+ }
+ const RTCStats* Get(const std::string& id) const;
+ size_t size() const { return stats_.size(); }
+
+ // Gets the stat object of type `T` by ID, where `T` is any class descending
+ // from `RTCStats`.
+ // Returns null if there is no stats object for the given ID or it is the
+ // wrong type.
+ template <typename T>
+ const T* GetAs(const std::string& id) const {
+ const RTCStats* stats = Get(id);
+ if (!stats || stats->type() != T::kType) {
+ return nullptr;
+ }
+ return &stats->cast_to<const T>();
+ }
+
+ // Removes the stats object from the report, returning ownership of it or null
+ // if there is no object with `id`.
+ std::unique_ptr<const RTCStats> Take(const std::string& id);
+ // Takes ownership of all the stats in `other`, leaving it empty.
+ void TakeMembersFrom(rtc::scoped_refptr<RTCStatsReport> other);
+
+ // Stats iterators. Stats are ordered lexicographically on `RTCStats::id`.
+ ConstIterator begin() const;
+ ConstIterator end() const;
+
+ // Gets the subset of stats that are of type `T`, where `T` is any class
+ // descending from `RTCStats`.
+ template <typename T>
+ std::vector<const T*> GetStatsOfType() const {
+ std::vector<const T*> stats_of_type;
+ for (const RTCStats& stats : *this) {
+ if (stats.type() == T::kType)
+ stats_of_type.push_back(&stats.cast_to<const T>());
+ }
+ return stats_of_type;
+ }
+
+ // Creates a JSON readable string representation of the report,
+ // listing all of its stats objects.
+ std::string ToJson() const;
+
+ protected:
+ friend class rtc::RefCountedNonVirtual<RTCStatsReport>;
+ ~RTCStatsReport() = default;
+
+ private:
+ Timestamp timestamp_;
+ StatsMap stats_;
+};
+
+} // namespace webrtc
+
+#endif // API_STATS_RTC_STATS_REPORT_H_
diff --git a/third_party/libwebrtc/api/stats/rtcstats_objects.h b/third_party/libwebrtc/api/stats/rtcstats_objects.h
new file mode 100644
index 0000000000..e5de2100bb
--- /dev/null
+++ b/third_party/libwebrtc/api/stats/rtcstats_objects.h
@@ -0,0 +1,722 @@
+/*
+ * Copyright 2016 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.
+ */
+
+#ifndef API_STATS_RTCSTATS_OBJECTS_H_
+#define API_STATS_RTCSTATS_OBJECTS_H_
+
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "api/stats/rtc_stats.h"
+#include "rtc_base/system/rtc_export.h"
+
+namespace webrtc {
+
+// https://w3c.github.io/webrtc-pc/#idl-def-rtcdatachannelstate
+struct RTCDataChannelState {
+ static const char* const kConnecting;
+ static const char* const kOpen;
+ static const char* const kClosing;
+ static const char* const kClosed;
+};
+
+// https://w3c.github.io/webrtc-stats/#dom-rtcstatsicecandidatepairstate
+struct RTCStatsIceCandidatePairState {
+ static const char* const kFrozen;
+ static const char* const kWaiting;
+ static const char* const kInProgress;
+ static const char* const kFailed;
+ static const char* const kSucceeded;
+};
+
+// https://w3c.github.io/webrtc-pc/#rtcicecandidatetype-enum
+struct RTCIceCandidateType {
+ static const char* const kHost;
+ static const char* const kSrflx;
+ static const char* const kPrflx;
+ static const char* const kRelay;
+};
+
+// https://w3c.github.io/webrtc-pc/#idl-def-rtcdtlstransportstate
+struct RTCDtlsTransportState {
+ static const char* const kNew;
+ static const char* const kConnecting;
+ static const char* const kConnected;
+ static const char* const kClosed;
+ static const char* const kFailed;
+};
+
+// `RTCMediaStreamTrackStats::kind` is not an enum in the spec but the only
+// valid values are "audio" and "video".
+// https://w3c.github.io/webrtc-stats/#dom-rtcmediastreamtrackstats-kind
+struct RTCMediaStreamTrackKind {
+ static const char* const kAudio;
+ static const char* const kVideo;
+};
+
+// https://w3c.github.io/webrtc-stats/#dom-rtcnetworktype
+struct RTCNetworkType {
+ static const char* const kBluetooth;
+ static const char* const kCellular;
+ static const char* const kEthernet;
+ static const char* const kWifi;
+ static const char* const kWimax;
+ static const char* const kVpn;
+ static const char* const kUnknown;
+};
+
+// https://w3c.github.io/webrtc-stats/#dom-rtcqualitylimitationreason
+struct RTCQualityLimitationReason {
+ static const char* const kNone;
+ static const char* const kCpu;
+ static const char* const kBandwidth;
+ static const char* const kOther;
+};
+
+// https://webrtc.org/experiments/rtp-hdrext/video-content-type/
+struct RTCContentType {
+ static const char* const kUnspecified;
+ static const char* const kScreenshare;
+};
+
+// https://w3c.github.io/webrtc-stats/#dom-rtcdtlsrole
+struct RTCDtlsRole {
+ static const char* const kUnknown;
+ static const char* const kClient;
+ static const char* const kServer;
+};
+
+// https://www.w3.org/TR/webrtc/#rtcicerole
+struct RTCIceRole {
+ static const char* const kUnknown;
+ static const char* const kControlled;
+ static const char* const kControlling;
+};
+
+// https://www.w3.org/TR/webrtc/#dom-rtcicetransportstate
+struct RTCIceTransportState {
+ static const char* const kNew;
+ static const char* const kChecking;
+ static const char* const kConnected;
+ static const char* const kCompleted;
+ static const char* const kDisconnected;
+ static const char* const kFailed;
+ static const char* const kClosed;
+};
+
+// https://w3c.github.io/webrtc-stats/#certificatestats-dict*
+class RTC_EXPORT RTCCertificateStats final : public RTCStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCCertificateStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCCertificateStats(std::string id, int64_t timestamp_us);
+ RTCCertificateStats(const RTCCertificateStats& other);
+ ~RTCCertificateStats() override;
+
+ RTCStatsMember<std::string> fingerprint;
+ RTCStatsMember<std::string> fingerprint_algorithm;
+ RTCStatsMember<std::string> base64_certificate;
+ RTCStatsMember<std::string> issuer_certificate_id;
+};
+
+// Non standard extension mapping to rtc::AdapterType
+struct RTCNetworkAdapterType {
+ static constexpr char kUnknown[] = "unknown";
+ static constexpr char kEthernet[] = "ethernet";
+ static constexpr char kWifi[] = "wifi";
+ static constexpr char kCellular[] = "cellular";
+ static constexpr char kLoopback[] = "loopback";
+ static constexpr char kAny[] = "any";
+ static constexpr char kCellular2g[] = "cellular2g";
+ static constexpr char kCellular3g[] = "cellular3g";
+ static constexpr char kCellular4g[] = "cellular4g";
+ static constexpr char kCellular5g[] = "cellular5g";
+};
+
+// https://w3c.github.io/webrtc-stats/#codec-dict*
+class RTC_EXPORT RTCCodecStats final : public RTCStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCCodecStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCCodecStats(std::string id, int64_t timestamp_us);
+ RTCCodecStats(const RTCCodecStats& other);
+ ~RTCCodecStats() override;
+
+ RTCStatsMember<std::string> transport_id;
+ RTCStatsMember<uint32_t> payload_type;
+ RTCStatsMember<std::string> mime_type;
+ RTCStatsMember<uint32_t> clock_rate;
+ RTCStatsMember<uint32_t> channels;
+ RTCStatsMember<std::string> sdp_fmtp_line;
+};
+
+// https://w3c.github.io/webrtc-stats/#dcstats-dict*
+class RTC_EXPORT RTCDataChannelStats final : public RTCStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCDataChannelStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCDataChannelStats(std::string id, int64_t timestamp_us);
+ RTCDataChannelStats(const RTCDataChannelStats& other);
+ ~RTCDataChannelStats() override;
+
+ RTCStatsMember<std::string> label;
+ RTCStatsMember<std::string> protocol;
+ RTCStatsMember<int32_t> data_channel_identifier;
+ // Enum type RTCDataChannelState.
+ RTCStatsMember<std::string> state;
+ RTCStatsMember<uint32_t> messages_sent;
+ RTCStatsMember<uint64_t> bytes_sent;
+ RTCStatsMember<uint32_t> messages_received;
+ RTCStatsMember<uint64_t> bytes_received;
+};
+
+// https://w3c.github.io/webrtc-stats/#candidatepair-dict*
+class RTC_EXPORT RTCIceCandidatePairStats final : public RTCStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCIceCandidatePairStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCIceCandidatePairStats(std::string id, int64_t timestamp_us);
+ RTCIceCandidatePairStats(const RTCIceCandidatePairStats& other);
+ ~RTCIceCandidatePairStats() override;
+
+ RTCStatsMember<std::string> transport_id;
+ RTCStatsMember<std::string> local_candidate_id;
+ RTCStatsMember<std::string> remote_candidate_id;
+ // Enum type RTCStatsIceCandidatePairState.
+ RTCStatsMember<std::string> state;
+ // Obsolete: priority
+ RTCStatsMember<uint64_t> priority;
+ RTCStatsMember<bool> nominated;
+ // `writable` does not exist in the spec and old comments suggest it used to
+ // exist but was incorrectly implemented.
+ // TODO(https://crbug.com/webrtc/14171): Standardize and/or modify
+ // implementation.
+ RTCStatsMember<bool> writable;
+ RTCStatsMember<uint64_t> packets_sent;
+ RTCStatsMember<uint64_t> packets_received;
+ RTCStatsMember<uint64_t> bytes_sent;
+ RTCStatsMember<uint64_t> bytes_received;
+ RTCStatsMember<double> total_round_trip_time;
+ RTCStatsMember<double> current_round_trip_time;
+ RTCStatsMember<double> available_outgoing_bitrate;
+ RTCStatsMember<double> available_incoming_bitrate;
+ RTCStatsMember<uint64_t> requests_received;
+ RTCStatsMember<uint64_t> requests_sent;
+ RTCStatsMember<uint64_t> responses_received;
+ RTCStatsMember<uint64_t> responses_sent;
+ RTCStatsMember<uint64_t> consent_requests_sent;
+ RTCStatsMember<uint64_t> packets_discarded_on_send;
+ RTCStatsMember<uint64_t> bytes_discarded_on_send;
+ RTCStatsMember<double> last_packet_received_timestamp;
+ RTCStatsMember<double> last_packet_sent_timestamp;
+};
+
+// https://w3c.github.io/webrtc-stats/#icecandidate-dict*
+class RTC_EXPORT RTCIceCandidateStats : public RTCStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCIceCandidateStats(const RTCIceCandidateStats& other);
+ ~RTCIceCandidateStats() override;
+
+ RTCStatsMember<std::string> transport_id;
+ // Obsolete: is_remote
+ RTCStatsMember<bool> is_remote;
+ RTCStatsMember<std::string> network_type;
+ RTCStatsMember<std::string> ip;
+ RTCStatsMember<std::string> address;
+ RTCStatsMember<int32_t> port;
+ RTCStatsMember<std::string> protocol;
+ RTCStatsMember<std::string> relay_protocol;
+ // Enum type RTCIceCandidateType.
+ RTCStatsMember<std::string> candidate_type;
+ RTCStatsMember<int32_t> priority;
+ RTCStatsMember<std::string> url;
+ RTCStatsMember<std::string> foundation;
+ RTCStatsMember<std::string> related_address;
+ RTCStatsMember<int32_t> related_port;
+ RTCStatsMember<std::string> username_fragment;
+ // Enum type RTCIceTcpCandidateType.
+ RTCStatsMember<std::string> tcp_type;
+
+ RTCNonStandardStatsMember<bool> vpn;
+ RTCNonStandardStatsMember<std::string> network_adapter_type;
+
+ protected:
+ RTCIceCandidateStats(std::string id, Timestamp timestamp, bool is_remote);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCIceCandidateStats(std::string id, int64_t timestamp_us, bool is_remote);
+};
+
+// In the spec both local and remote varieties are of type RTCIceCandidateStats.
+// But here we define them as subclasses of `RTCIceCandidateStats` because the
+// `kType` need to be different ("RTCStatsType type") in the local/remote case.
+// https://w3c.github.io/webrtc-stats/#rtcstatstype-str*
+// This forces us to have to override copy() and type().
+class RTC_EXPORT RTCLocalIceCandidateStats final : public RTCIceCandidateStats {
+ public:
+ static const char kType[];
+ RTCLocalIceCandidateStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCLocalIceCandidateStats(std::string id, int64_t timestamp_us);
+ std::unique_ptr<RTCStats> copy() const override;
+ const char* type() const override;
+};
+
+class RTC_EXPORT RTCRemoteIceCandidateStats final
+ : public RTCIceCandidateStats {
+ public:
+ static const char kType[];
+ RTCRemoteIceCandidateStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCRemoteIceCandidateStats(std::string id, int64_t timestamp_us);
+ std::unique_ptr<RTCStats> copy() const override;
+ const char* type() const override;
+};
+
+// TODO(https://crbug.com/webrtc/14419): Delete this class, it's deprecated.
+class RTC_EXPORT DEPRECATED_RTCMediaStreamStats final : public RTCStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ DEPRECATED_RTCMediaStreamStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ DEPRECATED_RTCMediaStreamStats(std::string id, int64_t timestamp_us);
+ DEPRECATED_RTCMediaStreamStats(const DEPRECATED_RTCMediaStreamStats& other);
+ ~DEPRECATED_RTCMediaStreamStats() override;
+
+ RTCStatsMember<std::string> stream_identifier;
+ RTCStatsMember<std::vector<std::string>> track_ids;
+};
+using RTCMediaStreamStats [[deprecated("bugs.webrtc.org/14419")]] =
+ DEPRECATED_RTCMediaStreamStats;
+
+// TODO(https://crbug.com/webrtc/14175): Delete this class, it's deprecated.
+class RTC_EXPORT DEPRECATED_RTCMediaStreamTrackStats final : public RTCStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ DEPRECATED_RTCMediaStreamTrackStats(std::string id,
+ Timestamp timestamp,
+ const char* kind);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ DEPRECATED_RTCMediaStreamTrackStats(std::string id,
+ int64_t timestamp_us,
+ const char* kind);
+ DEPRECATED_RTCMediaStreamTrackStats(
+ const DEPRECATED_RTCMediaStreamTrackStats& other);
+ ~DEPRECATED_RTCMediaStreamTrackStats() override;
+
+ RTCStatsMember<std::string> track_identifier;
+ RTCStatsMember<std::string> media_source_id;
+ RTCStatsMember<bool> remote_source;
+ RTCStatsMember<bool> ended;
+ // TODO(https://crbug.com/webrtc/14173): Remove this obsolete metric.
+ RTCStatsMember<bool> detached;
+ // Enum type RTCMediaStreamTrackKind.
+ RTCStatsMember<std::string> kind;
+ RTCStatsMember<double> jitter_buffer_delay;
+ RTCStatsMember<uint64_t> jitter_buffer_emitted_count;
+ // Video-only members
+ RTCStatsMember<uint32_t> frame_width;
+ RTCStatsMember<uint32_t> frame_height;
+ RTCStatsMember<uint32_t> frames_sent;
+ RTCStatsMember<uint32_t> huge_frames_sent;
+ RTCStatsMember<uint32_t> frames_received;
+ RTCStatsMember<uint32_t> frames_decoded;
+ RTCStatsMember<uint32_t> frames_dropped;
+ // Audio-only members
+ RTCStatsMember<double> audio_level; // Receive-only
+ RTCStatsMember<double> total_audio_energy; // Receive-only
+ RTCStatsMember<double> echo_return_loss;
+ RTCStatsMember<double> echo_return_loss_enhancement;
+ RTCStatsMember<uint64_t> total_samples_received;
+ RTCStatsMember<double> total_samples_duration; // Receive-only
+ RTCStatsMember<uint64_t> concealed_samples;
+ RTCStatsMember<uint64_t> silent_concealed_samples;
+ RTCStatsMember<uint64_t> concealment_events;
+ RTCStatsMember<uint64_t> inserted_samples_for_deceleration;
+ RTCStatsMember<uint64_t> removed_samples_for_acceleration;
+};
+using RTCMediaStreamTrackStats [[deprecated("bugs.webrtc.org/14175")]] =
+ DEPRECATED_RTCMediaStreamTrackStats;
+
+// https://w3c.github.io/webrtc-stats/#pcstats-dict*
+class RTC_EXPORT RTCPeerConnectionStats final : public RTCStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCPeerConnectionStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCPeerConnectionStats(std::string id, int64_t timestamp_us);
+ RTCPeerConnectionStats(const RTCPeerConnectionStats& other);
+ ~RTCPeerConnectionStats() override;
+
+ RTCStatsMember<uint32_t> data_channels_opened;
+ RTCStatsMember<uint32_t> data_channels_closed;
+};
+
+// https://w3c.github.io/webrtc-stats/#streamstats-dict*
+class RTC_EXPORT RTCRTPStreamStats : public RTCStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCRTPStreamStats(const RTCRTPStreamStats& other);
+ ~RTCRTPStreamStats() override;
+
+ RTCStatsMember<uint32_t> ssrc;
+ RTCStatsMember<std::string> kind;
+ // Obsolete: track_id
+ RTCStatsMember<std::string> track_id;
+ RTCStatsMember<std::string> transport_id;
+ RTCStatsMember<std::string> codec_id;
+
+ // Obsolete
+ RTCStatsMember<std::string> media_type; // renamed to kind.
+
+ protected:
+ RTCRTPStreamStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCRTPStreamStats(std::string id, int64_t timestamp_us);
+};
+
+// https://www.w3.org/TR/webrtc-stats/#receivedrtpstats-dict*
+class RTC_EXPORT RTCReceivedRtpStreamStats : public RTCRTPStreamStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCReceivedRtpStreamStats(const RTCReceivedRtpStreamStats& other);
+ ~RTCReceivedRtpStreamStats() override;
+
+ RTCStatsMember<double> jitter;
+ RTCStatsMember<int32_t> packets_lost; // Signed per RFC 3550
+
+ protected:
+ RTCReceivedRtpStreamStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCReceivedRtpStreamStats(std::string id, int64_t timestamp_us);
+};
+
+// https://www.w3.org/TR/webrtc-stats/#sentrtpstats-dict*
+class RTC_EXPORT RTCSentRtpStreamStats : public RTCRTPStreamStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCSentRtpStreamStats(const RTCSentRtpStreamStats& other);
+ ~RTCSentRtpStreamStats() override;
+
+ RTCStatsMember<uint32_t> packets_sent;
+ RTCStatsMember<uint64_t> bytes_sent;
+
+ protected:
+ RTCSentRtpStreamStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCSentRtpStreamStats(std::string id, int64_t timestamp_us);
+};
+
+// https://w3c.github.io/webrtc-stats/#inboundrtpstats-dict*
+class RTC_EXPORT RTCInboundRTPStreamStats final
+ : public RTCReceivedRtpStreamStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCInboundRTPStreamStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCInboundRTPStreamStats(std::string id, int64_t timestamp_us);
+ RTCInboundRTPStreamStats(const RTCInboundRTPStreamStats& other);
+ ~RTCInboundRTPStreamStats() override;
+
+ // TODO(https://crbug.com/webrtc/14174): Implement trackIdentifier and kind.
+
+ RTCStatsMember<std::string> playout_id;
+ RTCStatsMember<std::string> track_identifier;
+ RTCStatsMember<std::string> mid;
+ RTCStatsMember<std::string> remote_id;
+ RTCStatsMember<uint32_t> packets_received;
+ RTCStatsMember<uint64_t> packets_discarded;
+ RTCStatsMember<uint64_t> fec_packets_received;
+ RTCStatsMember<uint64_t> fec_packets_discarded;
+ RTCStatsMember<uint64_t> bytes_received;
+ RTCStatsMember<uint64_t> header_bytes_received;
+ RTCStatsMember<double> last_packet_received_timestamp;
+ RTCStatsMember<double> jitter_buffer_delay;
+ RTCStatsMember<double> jitter_buffer_target_delay;
+ RTCStatsMember<double> jitter_buffer_minimum_delay;
+ RTCStatsMember<uint64_t> jitter_buffer_emitted_count;
+ RTCStatsMember<uint64_t> total_samples_received;
+ RTCStatsMember<uint64_t> concealed_samples;
+ RTCStatsMember<uint64_t> silent_concealed_samples;
+ RTCStatsMember<uint64_t> concealment_events;
+ RTCStatsMember<uint64_t> inserted_samples_for_deceleration;
+ RTCStatsMember<uint64_t> removed_samples_for_acceleration;
+ RTCStatsMember<double> audio_level;
+ RTCStatsMember<double> total_audio_energy;
+ RTCStatsMember<double> total_samples_duration;
+ // Stats below are only implemented or defined for video.
+ RTCStatsMember<int32_t> frames_received;
+ RTCStatsMember<uint32_t> frame_width;
+ RTCStatsMember<uint32_t> frame_height;
+ RTCStatsMember<double> frames_per_second;
+ RTCStatsMember<uint32_t> frames_decoded;
+ RTCStatsMember<uint32_t> key_frames_decoded;
+ RTCStatsMember<uint32_t> frames_dropped;
+ RTCStatsMember<double> total_decode_time;
+ RTCStatsMember<double> total_processing_delay;
+ RTCStatsMember<double> total_assembly_time;
+ RTCStatsMember<uint32_t> frames_assembled_from_multiple_packets;
+ RTCStatsMember<double> total_inter_frame_delay;
+ RTCStatsMember<double> total_squared_inter_frame_delay;
+ RTCStatsMember<uint32_t> pause_count;
+ RTCStatsMember<double> total_pauses_duration;
+ RTCStatsMember<uint32_t> freeze_count;
+ RTCStatsMember<double> total_freezes_duration;
+ // https://w3c.github.io/webrtc-provisional-stats/#dom-rtcinboundrtpstreamstats-contenttype
+ RTCStatsMember<std::string> content_type;
+ // Only populated if audio/video sync is enabled.
+ // TODO(https://crbug.com/webrtc/14177): Expose even if A/V sync is off?
+ RTCStatsMember<double> estimated_playout_timestamp;
+ // Only implemented for video.
+ // TODO(https://crbug.com/webrtc/14178): Also implement for audio.
+ RTCRestrictedStatsMember<std::string,
+ StatExposureCriteria::kHardwareCapability>
+ decoder_implementation;
+ // FIR and PLI counts are only defined for |kind == "video"|.
+ RTCStatsMember<uint32_t> fir_count;
+ RTCStatsMember<uint32_t> pli_count;
+ RTCStatsMember<uint32_t> nack_count;
+ RTCStatsMember<uint64_t> qp_sum;
+ // This is a remnant of the legacy getStats() API. When the "video-timing"
+ // header extension is used,
+ // https://webrtc.github.io/webrtc-org/experiments/rtp-hdrext/video-timing/,
+ // `googTimingFrameInfo` is exposed with the value of
+ // TimingFrameInfo::ToString().
+ // TODO(https://crbug.com/webrtc/14586): Unship or standardize this metric.
+ RTCStatsMember<std::string> goog_timing_frame_info;
+ RTCRestrictedStatsMember<bool, StatExposureCriteria::kHardwareCapability>
+ power_efficient_decoder;
+ // Non-standard audio metrics.
+ RTCNonStandardStatsMember<uint64_t> jitter_buffer_flushes;
+ RTCNonStandardStatsMember<uint64_t> delayed_packet_outage_samples;
+ RTCNonStandardStatsMember<double> relative_packet_arrival_delay;
+ RTCNonStandardStatsMember<uint32_t> interruption_count;
+ RTCNonStandardStatsMember<double> total_interruption_duration;
+
+ // The former googMinPlayoutDelayMs (in seconds).
+ RTCNonStandardStatsMember<double> min_playout_delay;
+};
+
+// https://w3c.github.io/webrtc-stats/#outboundrtpstats-dict*
+class RTC_EXPORT RTCOutboundRTPStreamStats final : public RTCRTPStreamStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCOutboundRTPStreamStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCOutboundRTPStreamStats(std::string id, int64_t timestamp_us);
+ RTCOutboundRTPStreamStats(const RTCOutboundRTPStreamStats& other);
+ ~RTCOutboundRTPStreamStats() override;
+
+ RTCStatsMember<std::string> media_source_id;
+ RTCStatsMember<std::string> remote_id;
+ RTCStatsMember<std::string> mid;
+ RTCStatsMember<std::string> rid;
+ RTCStatsMember<uint32_t> packets_sent;
+ RTCStatsMember<uint64_t> retransmitted_packets_sent;
+ RTCStatsMember<uint64_t> bytes_sent;
+ RTCStatsMember<uint64_t> header_bytes_sent;
+ RTCStatsMember<uint64_t> retransmitted_bytes_sent;
+ RTCStatsMember<double> target_bitrate;
+ RTCStatsMember<uint32_t> frames_encoded;
+ RTCStatsMember<uint32_t> key_frames_encoded;
+ RTCStatsMember<double> total_encode_time;
+ RTCStatsMember<uint64_t> total_encoded_bytes_target;
+ RTCStatsMember<uint32_t> frame_width;
+ RTCStatsMember<uint32_t> frame_height;
+ RTCStatsMember<double> frames_per_second;
+ RTCStatsMember<uint32_t> frames_sent;
+ RTCStatsMember<uint32_t> huge_frames_sent;
+ RTCStatsMember<double> total_packet_send_delay;
+ // Enum type RTCQualityLimitationReason
+ RTCStatsMember<std::string> quality_limitation_reason;
+ RTCStatsMember<std::map<std::string, double>> quality_limitation_durations;
+ // https://w3c.github.io/webrtc-stats/#dom-rtcoutboundrtpstreamstats-qualitylimitationresolutionchanges
+ RTCStatsMember<uint32_t> quality_limitation_resolution_changes;
+ // https://w3c.github.io/webrtc-provisional-stats/#dom-rtcoutboundrtpstreamstats-contenttype
+ RTCStatsMember<std::string> content_type;
+ // Only implemented for video.
+ // TODO(https://crbug.com/webrtc/14178): Implement for audio as well.
+ RTCRestrictedStatsMember<std::string,
+ StatExposureCriteria::kHardwareCapability>
+ encoder_implementation;
+ // FIR and PLI counts are only defined for |kind == "video"|.
+ RTCStatsMember<uint32_t> fir_count;
+ RTCStatsMember<uint32_t> pli_count;
+ RTCStatsMember<uint32_t> nack_count;
+ RTCStatsMember<uint64_t> qp_sum;
+ RTCStatsMember<bool> active;
+ RTCRestrictedStatsMember<bool, StatExposureCriteria::kHardwareCapability>
+ power_efficient_encoder;
+ RTCStatsMember<std::string> scalability_mode;
+};
+
+// https://w3c.github.io/webrtc-stats/#remoteinboundrtpstats-dict*
+class RTC_EXPORT RTCRemoteInboundRtpStreamStats final
+ : public RTCReceivedRtpStreamStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCRemoteInboundRtpStreamStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCRemoteInboundRtpStreamStats(std::string id, int64_t timestamp_us);
+ RTCRemoteInboundRtpStreamStats(const RTCRemoteInboundRtpStreamStats& other);
+ ~RTCRemoteInboundRtpStreamStats() override;
+
+ RTCStatsMember<std::string> local_id;
+ RTCStatsMember<double> round_trip_time;
+ RTCStatsMember<double> fraction_lost;
+ RTCStatsMember<double> total_round_trip_time;
+ RTCStatsMember<int32_t> round_trip_time_measurements;
+};
+
+// https://w3c.github.io/webrtc-stats/#remoteoutboundrtpstats-dict*
+class RTC_EXPORT RTCRemoteOutboundRtpStreamStats final
+ : public RTCSentRtpStreamStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCRemoteOutboundRtpStreamStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCRemoteOutboundRtpStreamStats(std::string id, int64_t timestamp_us);
+ RTCRemoteOutboundRtpStreamStats(const RTCRemoteOutboundRtpStreamStats& other);
+ ~RTCRemoteOutboundRtpStreamStats() override;
+
+ RTCStatsMember<std::string> local_id;
+ RTCStatsMember<double> remote_timestamp;
+ RTCStatsMember<uint64_t> reports_sent;
+ RTCStatsMember<double> round_trip_time;
+ RTCStatsMember<uint64_t> round_trip_time_measurements;
+ RTCStatsMember<double> total_round_trip_time;
+};
+
+// https://w3c.github.io/webrtc-stats/#dom-rtcmediasourcestats
+class RTC_EXPORT RTCMediaSourceStats : public RTCStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCMediaSourceStats(const RTCMediaSourceStats& other);
+ ~RTCMediaSourceStats() override;
+
+ RTCStatsMember<std::string> track_identifier;
+ RTCStatsMember<std::string> kind;
+
+ protected:
+ RTCMediaSourceStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCMediaSourceStats(std::string id, int64_t timestamp_us);
+};
+
+// https://w3c.github.io/webrtc-stats/#dom-rtcaudiosourcestats
+class RTC_EXPORT RTCAudioSourceStats final : public RTCMediaSourceStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCAudioSourceStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCAudioSourceStats(std::string id, int64_t timestamp_us);
+ RTCAudioSourceStats(const RTCAudioSourceStats& other);
+ ~RTCAudioSourceStats() override;
+
+ RTCStatsMember<double> audio_level;
+ RTCStatsMember<double> total_audio_energy;
+ RTCStatsMember<double> total_samples_duration;
+ RTCStatsMember<double> echo_return_loss;
+ RTCStatsMember<double> echo_return_loss_enhancement;
+};
+
+// https://w3c.github.io/webrtc-stats/#dom-rtcvideosourcestats
+class RTC_EXPORT RTCVideoSourceStats final : public RTCMediaSourceStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCVideoSourceStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCVideoSourceStats(std::string id, int64_t timestamp_us);
+ RTCVideoSourceStats(const RTCVideoSourceStats& other);
+ ~RTCVideoSourceStats() override;
+
+ RTCStatsMember<uint32_t> width;
+ RTCStatsMember<uint32_t> height;
+ RTCStatsMember<uint32_t> frames;
+ RTCStatsMember<double> frames_per_second;
+};
+
+// https://w3c.github.io/webrtc-stats/#transportstats-dict*
+class RTC_EXPORT RTCTransportStats final : public RTCStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCTransportStats(std::string id, Timestamp timestamp);
+ ABSL_DEPRECATED("Use constructor with Timestamp instead")
+ RTCTransportStats(std::string id, int64_t timestamp_us);
+ RTCTransportStats(const RTCTransportStats& other);
+ ~RTCTransportStats() override;
+
+ RTCStatsMember<uint64_t> bytes_sent;
+ RTCStatsMember<uint64_t> packets_sent;
+ RTCStatsMember<uint64_t> bytes_received;
+ RTCStatsMember<uint64_t> packets_received;
+ RTCStatsMember<std::string> rtcp_transport_stats_id;
+ // Enum type RTCDtlsTransportState.
+ RTCStatsMember<std::string> dtls_state;
+ RTCStatsMember<std::string> selected_candidate_pair_id;
+ RTCStatsMember<std::string> local_certificate_id;
+ RTCStatsMember<std::string> remote_certificate_id;
+ RTCStatsMember<std::string> tls_version;
+ RTCStatsMember<std::string> dtls_cipher;
+ RTCStatsMember<std::string> dtls_role;
+ RTCStatsMember<std::string> srtp_cipher;
+ RTCStatsMember<uint32_t> selected_candidate_pair_changes;
+ RTCStatsMember<std::string> ice_role;
+ RTCStatsMember<std::string> ice_local_username_fragment;
+ RTCStatsMember<std::string> ice_state;
+};
+
+// https://w3c.github.io/webrtc-stats/#playoutstats-dict*
+class RTC_EXPORT RTCAudioPlayoutStats final : public RTCStats {
+ public:
+ WEBRTC_RTCSTATS_DECL();
+
+ RTCAudioPlayoutStats(const std::string& id, Timestamp timestamp);
+ RTCAudioPlayoutStats(const RTCAudioPlayoutStats& other);
+ ~RTCAudioPlayoutStats() override;
+
+ RTCStatsMember<std::string> kind;
+ RTCStatsMember<double> synthesized_samples_duration;
+ RTCStatsMember<uint64_t> synthesized_samples_events;
+ RTCStatsMember<double> total_samples_duration;
+ RTCStatsMember<double> total_playout_delay;
+ RTCStatsMember<uint64_t> total_samples_count;
+};
+
+} // namespace webrtc
+
+#endif // API_STATS_RTCSTATS_OBJECTS_H_