Repo created

TMessagesProj/jni/voip/webrtc/api/stats/OWNERS

@@ -0,0 +1,3 @@
+set noparent
+hbos@webrtc.org
+hta@webrtc.org

TMessagesProj/jni/voip/webrtc/api/stats/attribute.h

@@ -0,0 +1,94 @@
+/*
+ *  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.
+ */
+
+#ifndef API_STATS_ATTRIBUTE_H_
+#define API_STATS_ATTRIBUTE_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/system/rtc_export.h"
+
+namespace webrtc {
+
+// A light-weight wrapper of an RTCStats attribute, i.e. an individual metric of
+// type absl::optional<T>.
+class RTC_EXPORT Attribute {
+ public:
+  // All supported attribute types.
+  typedef absl::variant<const absl::optional<bool>*,
+                        const absl::optional<int32_t>*,
+                        const absl::optional<uint32_t>*,
+                        const absl::optional<int64_t>*,
+                        const absl::optional<uint64_t>*,
+                        const absl::optional<double>*,
+                        const absl::optional<std::string>*,
+                        const absl::optional<std::vector<bool>>*,
+                        const absl::optional<std::vector<int32_t>>*,
+                        const absl::optional<std::vector<uint32_t>>*,
+                        const absl::optional<std::vector<int64_t>>*,
+                        const absl::optional<std::vector<uint64_t>>*,
+                        const absl::optional<std::vector<double>>*,
+                        const absl::optional<std::vector<std::string>>*,
+                        const absl::optional<std::map<std::string, uint64_t>>*,
+                        const absl::optional<std::map<std::string, double>>*>
+      StatVariant;
+
+  template <typename T>
+  Attribute(const char* name, const absl::optional<T>* attribute)
+      : name_(name), attribute_(attribute) {}
+
+  const char* name() const;
+  const StatVariant& as_variant() const;
+
+  bool has_value() const;
+  template <typename T>
+  bool holds_alternative() const {
+    return absl::holds_alternative<const absl::optional<T>*>(attribute_);
+  }
+  template <typename T>
+  const absl::optional<T>& as_optional() const {
+    RTC_CHECK(holds_alternative<T>());
+    return *absl::get<const absl::optional<T>*>(attribute_);
+  }
+  template <typename T>
+  const T& get() const {
+    RTC_CHECK(holds_alternative<T>());
+    RTC_CHECK(has_value());
+    return absl::get<const absl::optional<T>*>(attribute_)->value();
+  }
+
+  bool is_sequence() const;
+  bool is_string() const;
+  std::string ToString() const;
+
+  bool operator==(const Attribute& other) const;
+  bool operator!=(const Attribute& other) const;
+
+ private:
+  const char* name_;
+  StatVariant attribute_;
+};
+
+struct RTC_EXPORT AttributeInit {
+  AttributeInit(const char* name, const Attribute::StatVariant& variant);
+
+  const char* name;
+  Attribute::StatVariant variant;
+};
+
+}  // namespace webrtc
+
+#endif  // API_STATS_ATTRIBUTE_H_

TMessagesProj/jni/voip/webrtc/api/stats/rtc_stats.h

@@ -0,0 +1,195 @@
+/*
+ *  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/stats/attribute.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 {
+
+// 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 attributes, absl::optional<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 attributes are available with `Attributes()`, allowing
+// iteration:
+//
+// for (const auto& attribute : foo.Attributes()) {
+//   printf("%s = %s\n", attribute.name(), attribute.ToString().c_str());
+// }
+class RTC_EXPORT RTCStats {
+ public:
+  RTCStats(const std::string& id, Timestamp timestamp)
+      : id_(id), timestamp_(timestamp) {}
+  RTCStats(const RTCStats& other);
+  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.
+  Timestamp timestamp() const { return timestamp_; }
+
+  // Returns the static member variable `kType` of the implementing class.
+  virtual const char* type() const = 0;
+  // Returns all attributes of this stats object, i.e. a list of its individual
+  // metrics as viewed via the Attribute wrapper.
+  std::vector<Attribute> Attributes() const;
+  template <typename T>
+  Attribute GetAttribute(const absl::optional<T>& stat) const {
+    for (const auto& attribute : Attributes()) {
+      if (!attribute.holds_alternative<T>()) {
+        continue;
+      }
+      if (absl::get<const absl::optional<T>*>(attribute.as_variant()) ==
+          &stat) {
+        return attribute;
+      }
+    }
+    RTC_CHECK_NOTREACHED();
+  }
+  // Checks if the two stats objects are of the same type and have the same
+  // attribute 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 attributes (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:
+  virtual std::vector<Attribute> AttributesImpl(
+      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
+// `AttributesImpl`. The |...| argument is a list of addresses to each attribute
+// defined in the implementing class. The list must have at least one attribute.
+//
+// (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, Timestamp timestamp);
+//
+//     absl::optional<int32_t> foo;
+//     absl::optional<int32_t> bar;
+//   };
+//
+// rtcfoostats.cc:
+//   WEBRTC_RTCSTATS_IMPL(RTCFooStats, RTCStats, "foo-stats"
+//       &foo,
+//       &bar);
+//
+//   RTCFooStats::RTCFooStats(const std::string& id, Timestamp timestamp)
+//       : RTCStats(id, timestamp),
+//         foo("foo"),
+//         bar("bar") {
+//   }
+//
+#define WEBRTC_RTCSTATS_DECL()                                              \
+ protected:                                                                 \
+  std::vector<webrtc::Attribute> AttributesImpl(size_t 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<webrtc::Attribute> this_class::AttributesImpl(                  \
+      size_t additional_capacity) const {                                     \
+    webrtc::AttributeInit attribute_inits[] = {__VA_ARGS__};                  \
+    size_t attribute_inits_size =                                             \
+        sizeof(attribute_inits) / sizeof(attribute_inits[0]);                 \
+    std::vector<webrtc::Attribute> attributes = parent_class::AttributesImpl( \
+        attribute_inits_size + additional_capacity);                          \
+    for (size_t i = 0; i < attribute_inits_size; ++i) {                       \
+      attributes.push_back(absl::visit(                                       \
+          [&](const auto* field) {                                            \
+            return Attribute(attribute_inits[i].name, field);                 \
+          },                                                                  \
+          attribute_inits[i].variant));                                       \
+    }                                                                         \
+    return attributes;                                                        \
+  }
+
+}  // namespace webrtc
+
+#endif  // API_STATS_RTC_STATS_H_

TMessagesProj/jni/voip/webrtc/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_

TMessagesProj/jni/voip/webrtc/api/stats/rtc_stats_report.h

@@ -0,0 +1,137 @@
+/*
+ *  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_;
+  };
+
+  static rtc::scoped_refptr<RTCStatsReport> Create(Timestamp timestamp);
+
+  explicit RTCStatsReport(Timestamp timestamp);
+
+  RTCStatsReport(const RTCStatsReport& other) = delete;
+  rtc::scoped_refptr<RTCStatsReport> Copy() const;
+
+  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 RefCountedNonVirtual<RTCStatsReport>;
+  ~RTCStatsReport() = default;
+
+ private:
+  Timestamp timestamp_;
+  StatsMap stats_;
+};
+
+}  // namespace webrtc
+
+#endif  // API_STATS_RTC_STATS_REPORT_H_

TMessagesProj/jni/voip/webrtc/api/stats/rtcstats_objects.h

@@ -0,0 +1,484 @@
+/*
+ *  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 "absl/types/optional.h"
+#include "api/stats/rtc_stats.h"
+#include "rtc_base/system/rtc_export.h"
+
+namespace webrtc {
+
+// 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);
+  ~RTCCertificateStats() override;
+
+  absl::optional<std::string> fingerprint;
+  absl::optional<std::string> fingerprint_algorithm;
+  absl::optional<std::string> base64_certificate;
+  absl::optional<std::string> issuer_certificate_id;
+};
+
+// 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);
+  ~RTCCodecStats() override;
+
+  absl::optional<std::string> transport_id;
+  absl::optional<uint32_t> payload_type;
+  absl::optional<std::string> mime_type;
+  absl::optional<uint32_t> clock_rate;
+  absl::optional<uint32_t> channels;
+  absl::optional<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);
+  ~RTCDataChannelStats() override;
+
+  absl::optional<std::string> label;
+  absl::optional<std::string> protocol;
+  absl::optional<int32_t> data_channel_identifier;
+  absl::optional<std::string> state;
+  absl::optional<uint32_t> messages_sent;
+  absl::optional<uint64_t> bytes_sent;
+  absl::optional<uint32_t> messages_received;
+  absl::optional<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);
+  ~RTCIceCandidatePairStats() override;
+
+  absl::optional<std::string> transport_id;
+  absl::optional<std::string> local_candidate_id;
+  absl::optional<std::string> remote_candidate_id;
+  absl::optional<std::string> state;
+  // Obsolete: priority
+  absl::optional<uint64_t> priority;
+  absl::optional<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.
+  absl::optional<bool> writable;
+  absl::optional<uint64_t> packets_sent;
+  absl::optional<uint64_t> packets_received;
+  absl::optional<uint64_t> bytes_sent;
+  absl::optional<uint64_t> bytes_received;
+  absl::optional<double> total_round_trip_time;
+  absl::optional<double> current_round_trip_time;
+  absl::optional<double> available_outgoing_bitrate;
+  absl::optional<double> available_incoming_bitrate;
+  absl::optional<uint64_t> requests_received;
+  absl::optional<uint64_t> requests_sent;
+  absl::optional<uint64_t> responses_received;
+  absl::optional<uint64_t> responses_sent;
+  absl::optional<uint64_t> consent_requests_sent;
+  absl::optional<uint64_t> packets_discarded_on_send;
+  absl::optional<uint64_t> bytes_discarded_on_send;
+  absl::optional<double> last_packet_received_timestamp;
+  absl::optional<double> last_packet_sent_timestamp;
+};
+
+// https://w3c.github.io/webrtc-stats/#icecandidate-dict*
+class RTC_EXPORT RTCIceCandidateStats : public RTCStats {
+ public:
+  WEBRTC_RTCSTATS_DECL();
+  ~RTCIceCandidateStats() override;
+
+  absl::optional<std::string> transport_id;
+  // Obsolete: is_remote
+  absl::optional<bool> is_remote;
+  absl::optional<std::string> network_type;
+  absl::optional<std::string> ip;
+  absl::optional<std::string> address;
+  absl::optional<int32_t> port;
+  absl::optional<std::string> protocol;
+  absl::optional<std::string> relay_protocol;
+  absl::optional<std::string> candidate_type;
+  absl::optional<int32_t> priority;
+  absl::optional<std::string> url;
+  absl::optional<std::string> foundation;
+  absl::optional<std::string> related_address;
+  absl::optional<int32_t> related_port;
+  absl::optional<std::string> username_fragment;
+  absl::optional<std::string> tcp_type;
+
+  // The following metrics are NOT exposed to JavaScript. We should consider
+  // standardizing or removing them.
+  absl::optional<bool> vpn;
+  absl::optional<std::string> network_adapter_type;
+
+ protected:
+  RTCIceCandidateStats(std::string id, Timestamp timestamp, 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);
+  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);
+  std::unique_ptr<RTCStats> copy() const override;
+  const char* type() const override;
+};
+
+// 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);
+  ~RTCPeerConnectionStats() override;
+
+  absl::optional<uint32_t> data_channels_opened;
+  absl::optional<uint32_t> data_channels_closed;
+};
+
+// https://w3c.github.io/webrtc-stats/#streamstats-dict*
+class RTC_EXPORT RTCRtpStreamStats : public RTCStats {
+ public:
+  WEBRTC_RTCSTATS_DECL();
+  ~RTCRtpStreamStats() override;
+
+  absl::optional<uint32_t> ssrc;
+  absl::optional<std::string> kind;
+  absl::optional<std::string> transport_id;
+  absl::optional<std::string> codec_id;
+
+ protected:
+  RTCRtpStreamStats(std::string id, Timestamp timestamp);
+};
+
+// https://www.w3.org/TR/webrtc-stats/#receivedrtpstats-dict*
+class RTC_EXPORT RTCReceivedRtpStreamStats : public RTCRtpStreamStats {
+ public:
+  WEBRTC_RTCSTATS_DECL();
+  ~RTCReceivedRtpStreamStats() override;
+
+  absl::optional<double> jitter;
+  absl::optional<int32_t> packets_lost;  // Signed per RFC 3550
+
+ protected:
+  RTCReceivedRtpStreamStats(std::string id, Timestamp timestamp);
+};
+
+// https://www.w3.org/TR/webrtc-stats/#sentrtpstats-dict*
+class RTC_EXPORT RTCSentRtpStreamStats : public RTCRtpStreamStats {
+ public:
+  WEBRTC_RTCSTATS_DECL();
+  ~RTCSentRtpStreamStats() override;
+
+  absl::optional<uint64_t> packets_sent;
+  absl::optional<uint64_t> bytes_sent;
+
+ protected:
+  RTCSentRtpStreamStats(std::string id, Timestamp timestamp);
+};
+
+// 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);
+  ~RTCInboundRtpStreamStats() override;
+
+  absl::optional<std::string> playout_id;
+  absl::optional<std::string> track_identifier;
+  absl::optional<std::string> mid;
+  absl::optional<std::string> remote_id;
+  absl::optional<uint32_t> packets_received;
+  absl::optional<uint64_t> packets_discarded;
+  absl::optional<uint64_t> fec_packets_received;
+  absl::optional<uint64_t> fec_bytes_received;
+  absl::optional<uint64_t> fec_packets_discarded;
+  // Inbound FEC SSRC. Only present if a mechanism like FlexFEC is negotiated.
+  absl::optional<uint32_t> fec_ssrc;
+  absl::optional<uint64_t> bytes_received;
+  absl::optional<uint64_t> header_bytes_received;
+  // Inbound RTX stats. Only defined when RTX is used and it is therefore
+  // possible to distinguish retransmissions.
+  absl::optional<uint64_t> retransmitted_packets_received;
+  absl::optional<uint64_t> retransmitted_bytes_received;
+  absl::optional<uint32_t> rtx_ssrc;
+
+  absl::optional<double> last_packet_received_timestamp;
+  absl::optional<double> jitter_buffer_delay;
+  absl::optional<double> jitter_buffer_target_delay;
+  absl::optional<double> jitter_buffer_minimum_delay;
+  absl::optional<uint64_t> jitter_buffer_emitted_count;
+  absl::optional<uint64_t> total_samples_received;
+  absl::optional<uint64_t> concealed_samples;
+  absl::optional<uint64_t> silent_concealed_samples;
+  absl::optional<uint64_t> concealment_events;
+  absl::optional<uint64_t> inserted_samples_for_deceleration;
+  absl::optional<uint64_t> removed_samples_for_acceleration;
+  absl::optional<double> audio_level;
+  absl::optional<double> total_audio_energy;
+  absl::optional<double> total_samples_duration;
+  // Stats below are only implemented or defined for video.
+  absl::optional<uint32_t> frames_received;
+  absl::optional<uint32_t> frame_width;
+  absl::optional<uint32_t> frame_height;
+  absl::optional<double> frames_per_second;
+  absl::optional<uint32_t> frames_decoded;
+  absl::optional<uint32_t> key_frames_decoded;
+  absl::optional<uint32_t> frames_dropped;
+  absl::optional<double> total_decode_time;
+  absl::optional<double> total_processing_delay;
+  absl::optional<double> total_assembly_time;
+  absl::optional<uint32_t> frames_assembled_from_multiple_packets;
+  // TODO(https://crbug.com/webrtc/15600): Implement framesRendered, which is
+  // incremented at the same time that totalInterFrameDelay and
+  // totalSquaredInterFrameDelay is incremented. (Dividing inter-frame delay by
+  // framesDecoded is slightly wrong.)
+  // https://w3c.github.io/webrtc-stats/#dom-rtcinboundrtpstreamstats-framesrendered
+  //
+  // TODO(https://crbug.com/webrtc/15601): Inter-frame, pause and freeze metrics
+  // all related to when the frame is rendered, but our implementation measures
+  // at delivery to sink, not at actual render time. When we have an actual
+  // frame rendered callback, move the calculating of these metrics to there in
+  // order to make them more accurate.
+  absl::optional<double> total_inter_frame_delay;
+  absl::optional<double> total_squared_inter_frame_delay;
+  absl::optional<uint32_t> pause_count;
+  absl::optional<double> total_pauses_duration;
+  absl::optional<uint32_t> freeze_count;
+  absl::optional<double> total_freezes_duration;
+  // https://w3c.github.io/webrtc-provisional-stats/#dom-rtcinboundrtpstreamstats-contenttype
+  absl::optional<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?
+  absl::optional<double> estimated_playout_timestamp;
+  // Only defined for video.
+  // In JavaScript, this is only exposed if HW exposure is allowed.
+  absl::optional<std::string> decoder_implementation;
+  // FIR and PLI counts are only defined for |kind == "video"|.
+  absl::optional<uint32_t> fir_count;
+  absl::optional<uint32_t> pli_count;
+  absl::optional<uint32_t> nack_count;
+  absl::optional<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.
+  absl::optional<std::string> goog_timing_frame_info;
+  // In JavaScript, this is only exposed if HW exposure is allowed.
+  absl::optional<bool> power_efficient_decoder;
+
+  // The following metrics are NOT exposed to JavaScript. We should consider
+  // standardizing or removing them.
+  absl::optional<uint64_t> jitter_buffer_flushes;
+  absl::optional<uint64_t> delayed_packet_outage_samples;
+  absl::optional<double> relative_packet_arrival_delay;
+  absl::optional<uint32_t> interruption_count;
+  absl::optional<double> total_interruption_duration;
+  absl::optional<double> min_playout_delay;
+};
+
+// https://w3c.github.io/webrtc-stats/#outboundrtpstats-dict*
+class RTC_EXPORT RTCOutboundRtpStreamStats final
+    : public RTCSentRtpStreamStats {
+ public:
+  WEBRTC_RTCSTATS_DECL();
+  RTCOutboundRtpStreamStats(std::string id, Timestamp timestamp);
+  ~RTCOutboundRtpStreamStats() override;
+
+  absl::optional<std::string> media_source_id;
+  absl::optional<std::string> remote_id;
+  absl::optional<std::string> mid;
+  absl::optional<std::string> rid;
+  absl::optional<uint64_t> retransmitted_packets_sent;
+  absl::optional<uint64_t> header_bytes_sent;
+  absl::optional<uint64_t> retransmitted_bytes_sent;
+  absl::optional<double> target_bitrate;
+  absl::optional<uint32_t> frames_encoded;
+  absl::optional<uint32_t> key_frames_encoded;
+  absl::optional<double> total_encode_time;
+  absl::optional<uint64_t> total_encoded_bytes_target;
+  absl::optional<uint32_t> frame_width;
+  absl::optional<uint32_t> frame_height;
+  absl::optional<double> frames_per_second;
+  absl::optional<uint32_t> frames_sent;
+  absl::optional<uint32_t> huge_frames_sent;
+  absl::optional<double> total_packet_send_delay;
+  absl::optional<std::string> quality_limitation_reason;
+  absl::optional<std::map<std::string, double>> quality_limitation_durations;
+  // https://w3c.github.io/webrtc-stats/#dom-rtcoutboundrtpstreamstats-qualitylimitationresolutionchanges
+  absl::optional<uint32_t> quality_limitation_resolution_changes;
+  // https://w3c.github.io/webrtc-provisional-stats/#dom-rtcoutboundrtpstreamstats-contenttype
+  absl::optional<std::string> content_type;
+  // In JavaScript, this is only exposed if HW exposure is allowed.
+  // Only implemented for video.
+  // TODO(https://crbug.com/webrtc/14178): Implement for audio as well.
+  absl::optional<std::string> encoder_implementation;
+  // FIR and PLI counts are only defined for |kind == "video"|.
+  absl::optional<uint32_t> fir_count;
+  absl::optional<uint32_t> pli_count;
+  absl::optional<uint32_t> nack_count;
+  absl::optional<uint64_t> qp_sum;
+  absl::optional<bool> active;
+  // In JavaScript, this is only exposed if HW exposure is allowed.
+  absl::optional<bool> power_efficient_encoder;
+  absl::optional<std::string> scalability_mode;
+
+  // RTX ssrc. Only present if RTX is negotiated.
+  absl::optional<uint32_t> rtx_ssrc;
+};
+
+// 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);
+  ~RTCRemoteInboundRtpStreamStats() override;
+
+  absl::optional<std::string> local_id;
+  absl::optional<double> round_trip_time;
+  absl::optional<double> fraction_lost;
+  absl::optional<double> total_round_trip_time;
+  absl::optional<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);
+  ~RTCRemoteOutboundRtpStreamStats() override;
+
+  absl::optional<std::string> local_id;
+  absl::optional<double> remote_timestamp;
+  absl::optional<uint64_t> reports_sent;
+  absl::optional<double> round_trip_time;
+  absl::optional<uint64_t> round_trip_time_measurements;
+  absl::optional<double> total_round_trip_time;
+};
+
+// https://w3c.github.io/webrtc-stats/#dom-rtcmediasourcestats
+class RTC_EXPORT RTCMediaSourceStats : public RTCStats {
+ public:
+  WEBRTC_RTCSTATS_DECL();
+  ~RTCMediaSourceStats() override;
+
+  absl::optional<std::string> track_identifier;
+  absl::optional<std::string> kind;
+
+ protected:
+  RTCMediaSourceStats(std::string id, Timestamp timestamp);
+};
+
+// 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);
+  ~RTCAudioSourceStats() override;
+
+  absl::optional<double> audio_level;
+  absl::optional<double> total_audio_energy;
+  absl::optional<double> total_samples_duration;
+  absl::optional<double> echo_return_loss;
+  absl::optional<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);
+  ~RTCVideoSourceStats() override;
+
+  absl::optional<uint32_t> width;
+  absl::optional<uint32_t> height;
+  absl::optional<uint32_t> frames;
+  absl::optional<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);
+  ~RTCTransportStats() override;
+
+  absl::optional<uint64_t> bytes_sent;
+  absl::optional<uint64_t> packets_sent;
+  absl::optional<uint64_t> bytes_received;
+  absl::optional<uint64_t> packets_received;
+  absl::optional<std::string> rtcp_transport_stats_id;
+  absl::optional<std::string> dtls_state;
+  absl::optional<std::string> selected_candidate_pair_id;
+  absl::optional<std::string> local_certificate_id;
+  absl::optional<std::string> remote_certificate_id;
+  absl::optional<std::string> tls_version;
+  absl::optional<std::string> dtls_cipher;
+  absl::optional<std::string> dtls_role;
+  absl::optional<std::string> srtp_cipher;
+  absl::optional<uint32_t> selected_candidate_pair_changes;
+  absl::optional<std::string> ice_role;
+  absl::optional<std::string> ice_local_username_fragment;
+  absl::optional<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() override;
+
+  absl::optional<std::string> kind;
+  absl::optional<double> synthesized_samples_duration;
+  absl::optional<uint64_t> synthesized_samples_events;
+  absl::optional<double> total_samples_duration;
+  absl::optional<double> total_playout_delay;
+  absl::optional<uint64_t> total_samples_count;
+};
+
+}  // namespace webrtc
+
+#endif  // API_STATS_RTCSTATS_OBJECTS_H_