Merging upstream version 127.0.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

4 files changed, 243 insertions, 429 deletions

diff --git a/third_party/libwebrtc/api/stats/attribute.h b/third_party/libwebrtc/api/stats/attribute.h
index 09211f469c..36500db999 100644
--- a/third_party/libwebrtc/api/stats/attribute.h
+++ b/third_party/libwebrtc/api/stats/attribute.h
@@ -16,37 +16,38 @@
 #include <string>
 #include <vector>
 
+#include "absl/types/optional.h"
 #include "absl/types/variant.h"
-#include "api/stats/rtc_stats_member.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/system/rtc_export.h"
 
 namespace webrtc {
 
-// A light-weight wrapper of an RTCStats attribute (an individual metric).
+// A light-weight wrapper of an RTCStats attribute, i.e. an individual metric of
+// type absl::optional<T>.
 class RTC_EXPORT Attribute {
  public:
-  // TODO(https://crbug.com/webrtc/15164): Replace uses of RTCStatsMember<T>
-  // with absl::optional<T> and update these pointer types.
-  typedef absl::variant<const RTCStatsMember<bool>*,
-                        const RTCStatsMember<int32_t>*,
-                        const RTCStatsMember<uint32_t>*,
-                        const RTCStatsMember<int64_t>*,
-                        const RTCStatsMember<uint64_t>*,
-                        const RTCStatsMember<double>*,
-                        const RTCStatsMember<std::string>*,
-                        const RTCStatsMember<std::vector<bool>>*,
-                        const RTCStatsMember<std::vector<int32_t>>*,
-                        const RTCStatsMember<std::vector<uint32_t>>*,
-                        const RTCStatsMember<std::vector<int64_t>>*,
-                        const RTCStatsMember<std::vector<uint64_t>>*,
-                        const RTCStatsMember<std::vector<double>>*,
-                        const RTCStatsMember<std::vector<std::string>>*,
-                        const RTCStatsMember<std::map<std::string, uint64_t>>*,
-                        const RTCStatsMember<std::map<std::string, double>>*>
+  // 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>
-  explicit Attribute(const char* name, const RTCStatsMember<T>* attribute)
+  Attribute(const char* name, const absl::optional<T>* attribute)
       : name_(name), attribute_(attribute) {}
 
   const char* name() const;
@@ -55,21 +56,18 @@ class RTC_EXPORT Attribute {
   bool has_value() const;
   template <typename T>
   bool holds_alternative() const {
-    return absl::holds_alternative<const RTCStatsMember<T>*>(attribute_);
+    return absl::holds_alternative<const absl::optional<T>*>(attribute_);
   }
   template <typename T>
-  absl::optional<T> as_optional() const {
+  const absl::optional<T>& as_optional() const {
     RTC_CHECK(holds_alternative<T>());
-    if (!has_value()) {
-      return absl::nullopt;
-    }
-    return absl::optional<T>(get<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 RTCStatsMember<T>*>(attribute_)->value();
+    return absl::get<const absl::optional<T>*>(attribute_)->value();
   }
 
   bool is_sequence() const;
diff --git a/third_party/libwebrtc/api/stats/rtc_stats.h b/third_party/libwebrtc/api/stats/rtc_stats.h
index edd293f5c9..74e7fc4d8e 100644
--- a/third_party/libwebrtc/api/stats/rtc_stats.h
+++ b/third_party/libwebrtc/api/stats/rtc_stats.h
@@ -20,8 +20,8 @@
 #include <utility>
 #include <vector>
 
+#include "absl/types/optional.h"
 #include "api/stats/attribute.h"
-#include "api/stats/rtc_stats_member.h"
 #include "api/units/timestamp.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/system/rtc_export.h"
@@ -39,8 +39,8 @@ namespace webrtc {
 // Use the `WEBRTC_RTCSTATS_IMPL` macro when implementing subclasses, see macro
 // for details.
 //
-// Derived classes list their dictionary attributes (RTCStatsMember<T> to soon
-// be replaced by absl::optional<T>) as public fields, allowing the following:
+// Derived classes list their dictionary attributes, absl::optional<T>, as
+// public fields, allowing the following:
 //
 // RTCFooStats foo("fooId", Timestamp::Micros(GetCurrentTime()));
 // foo.bar = 42;
@@ -52,7 +52,7 @@ namespace webrtc {
 // iteration:
 //
 // for (const auto& attribute : foo.Attributes()) {
-//   printf("%s = %s\n", attribute.name(), attribute.ValueToString().c_str());
+//   printf("%s = %s\n", attribute.name(), attribute.ToString().c_str());
 // }
 class RTC_EXPORT RTCStats {
  public:
@@ -73,12 +73,12 @@ class RTC_EXPORT RTCStats {
   // metrics as viewed via the Attribute wrapper.
   std::vector<Attribute> Attributes() const;
   template <typename T>
-  Attribute GetAttribute(const RTCStatsMember<T>& stat) const {
+  Attribute GetAttribute(const absl::optional<T>& stat) const {
     for (const auto& attribute : Attributes()) {
       if (!attribute.holds_alternative<T>()) {
         continue;
       }
-      if (absl::get<const RTCStatsMember<T>*>(attribute.as_variant()) ==
+      if (absl::get<const absl::optional<T>*>(attribute.as_variant()) ==
           &stat) {
         return attribute;
       }
@@ -136,8 +136,8 @@ class RTC_EXPORT RTCStats {
 //
 //     RTCFooStats(const std::string& id, Timestamp timestamp);
 //
-//     RTCStatsMember<int32_t> foo;
-//     RTCStatsMember<int32_t> bar;
+//     absl::optional<int32_t> foo;
+//     absl::optional<int32_t> bar;
 //   };
 //
 // rtcfoostats.cc:
diff --git a/third_party/libwebrtc/api/stats/rtc_stats_member.h b/third_party/libwebrtc/api/stats/rtc_stats_member.h
deleted file mode 100644
index 9039569ede..0000000000
--- a/third_party/libwebrtc/api/stats/rtc_stats_member.h
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
- *  Copyright 2023 The WebRTC Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef API_STATS_RTC_STATS_MEMBER_H_
-#define API_STATS_RTC_STATS_MEMBER_H_
-
-#include <map>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "absl/types/optional.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/system/rtc_export.h"
-#include "rtc_base/system/rtc_export_template.h"
-
-namespace webrtc {
-
-// 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() {}
-
-  virtual Type type() const = 0;
-  virtual bool is_sequence() const = 0;
-  virtual bool is_string() const = 0;
-  virtual bool has_value() const = 0;
-  // 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 const RTCStatsMemberInterface* member_ptr() const { return this; }
-  template <typename T>
-  const T& cast_to() const {
-    RTC_DCHECK_EQ(type(), T::StaticType());
-    return static_cast<const T&>(*member_ptr());
-  }
-
- protected:
-  virtual bool IsEqual(const RTCStatsMemberInterface& other) const = 0;
-};
-
-// Template implementation of `RTCStatsMemberInterface`.
-// The supported types are the ones described by
-// `RTCStatsMemberInterface::Type`.
-template <typename T>
-class RTCStatsMember : public RTCStatsMemberInterface {
- public:
-  RTCStatsMember() {}
-  explicit RTCStatsMember(const T& value) : value_(value) {}
-
-  static Type StaticType();
-  Type type() const override { return StaticType(); }
-  bool is_sequence() const override;
-  bool is_string() const override;
-
-  template <typename U>
-  inline T value_or(U default_value) const {
-    return value_.value_or(default_value);
-  }
-  // TODO(https://crbug.com/webrtc/15164): Migrate to value_or() and delete.
-  template <typename U>
-  inline T ValueOrDefault(U default_value) const {
-    return 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();
-  }
-
-  // Getter methods that look the same as absl::optional<T>. Please prefer these
-  // in order to unblock replacing RTCStatsMember<T> with absl::optional<T> in
-  // the future (https://crbug.com/webrtc/15164).
-  bool has_value() const override { return value_.has_value(); }
-  const T& value() const { return value_.value(); }
-  T& value() { return value_.value(); }
-  T& operator*() {
-    RTC_DCHECK(value_);
-    return *value_;
-  }
-  const T& operator*() const {
-    RTC_DCHECK(value_);
-    return *value_;
-  }
-  T* operator->() {
-    RTC_DCHECK(value_);
-    return &(*value_);
-  }
-  const T* operator->() const {
-    RTC_DCHECK(value_);
-    return &(*value_);
-  }
-
-  bool IsEqual(const RTCStatsMemberInterface& other) const override {
-    if (type() != other.type())
-      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;                     \
-  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);
-
-}  // namespace webrtc
-
-#endif  // API_STATS_RTC_STATS_MEMBER_H_
diff --git a/third_party/libwebrtc/api/stats/rtcstats_objects.h b/third_party/libwebrtc/api/stats/rtcstats_objects.h
index 351c2cbefe..9f51f56cc5 100644
--- a/third_party/libwebrtc/api/stats/rtcstats_objects.h
+++ b/third_party/libwebrtc/api/stats/rtcstats_objects.h
@@ -18,6 +18,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/types/optional.h"
 #include "api/stats/rtc_stats.h"
 #include "rtc_base/system/rtc_export.h"
 
@@ -30,10 +31,10 @@ class RTC_EXPORT RTCCertificateStats final : public RTCStats {
   RTCCertificateStats(std::string id, Timestamp timestamp);
   ~RTCCertificateStats() override;
 
-  RTCStatsMember<std::string> fingerprint;
-  RTCStatsMember<std::string> fingerprint_algorithm;
-  RTCStatsMember<std::string> base64_certificate;
-  RTCStatsMember<std::string> issuer_certificate_id;
+  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*
@@ -43,12 +44,12 @@ class RTC_EXPORT RTCCodecStats final : public RTCStats {
   RTCCodecStats(std::string id, Timestamp timestamp);
   ~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;
+  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*
@@ -58,14 +59,14 @@ class RTC_EXPORT RTCDataChannelStats final : public RTCStats {
   RTCDataChannelStats(std::string id, Timestamp timestamp);
   ~RTCDataChannelStats() override;
 
-  RTCStatsMember<std::string> label;
-  RTCStatsMember<std::string> protocol;
-  RTCStatsMember<int32_t> data_channel_identifier;
-  RTCStatsMember<std::string> state;
-  RTCStatsMember<uint32_t> messages_sent;
-  RTCStatsMember<uint64_t> bytes_sent;
-  RTCStatsMember<uint32_t> messages_received;
-  RTCStatsMember<uint64_t> bytes_received;
+  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*
@@ -75,35 +76,35 @@ class RTC_EXPORT RTCIceCandidatePairStats final : public RTCStats {
   RTCIceCandidatePairStats(std::string id, Timestamp timestamp);
   ~RTCIceCandidatePairStats() override;
 
-  RTCStatsMember<std::string> transport_id;
-  RTCStatsMember<std::string> local_candidate_id;
-  RTCStatsMember<std::string> remote_candidate_id;
-  RTCStatsMember<std::string> state;
+  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
-  RTCStatsMember<uint64_t> priority;
-  RTCStatsMember<bool> nominated;
+  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.
-  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;
+  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*
@@ -112,28 +113,28 @@ class RTC_EXPORT RTCIceCandidateStats : public RTCStats {
   WEBRTC_RTCSTATS_DECL();
   ~RTCIceCandidateStats() override;
 
-  RTCStatsMember<std::string> transport_id;
+  absl::optional<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;
-  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;
-  RTCStatsMember<std::string> tcp_type;
+  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.
-  RTCStatsMember<bool> vpn;
-  RTCStatsMember<std::string> network_adapter_type;
+  absl::optional<bool> vpn;
+  absl::optional<std::string> network_adapter_type;
 
  protected:
   RTCIceCandidateStats(std::string id, Timestamp timestamp, bool is_remote);
@@ -168,8 +169,8 @@ class RTC_EXPORT RTCPeerConnectionStats final : public RTCStats {
   RTCPeerConnectionStats(std::string id, Timestamp timestamp);
   ~RTCPeerConnectionStats() override;
 
-  RTCStatsMember<uint32_t> data_channels_opened;
-  RTCStatsMember<uint32_t> data_channels_closed;
+  absl::optional<uint32_t> data_channels_opened;
+  absl::optional<uint32_t> data_channels_closed;
 };
 
 // https://w3c.github.io/webrtc-stats/#streamstats-dict*
@@ -178,10 +179,10 @@ class RTC_EXPORT RTCRtpStreamStats : public RTCStats {
   WEBRTC_RTCSTATS_DECL();
   ~RTCRtpStreamStats() override;
 
-  RTCStatsMember<uint32_t> ssrc;
-  RTCStatsMember<std::string> kind;
-  RTCStatsMember<std::string> transport_id;
-  RTCStatsMember<std::string> codec_id;
+  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);
@@ -193,8 +194,8 @@ class RTC_EXPORT RTCReceivedRtpStreamStats : public RTCRtpStreamStats {
   WEBRTC_RTCSTATS_DECL();
   ~RTCReceivedRtpStreamStats() override;
 
-  RTCStatsMember<double> jitter;
-  RTCStatsMember<int32_t> packets_lost;  // Signed per RFC 3550
+  absl::optional<double> jitter;
+  absl::optional<int32_t> packets_lost;  // Signed per RFC 3550
 
  protected:
   RTCReceivedRtpStreamStats(std::string id, Timestamp timestamp);
@@ -206,8 +207,8 @@ class RTC_EXPORT RTCSentRtpStreamStats : public RTCRtpStreamStats {
   WEBRTC_RTCSTATS_DECL();
   ~RTCSentRtpStreamStats() override;
 
-  RTCStatsMember<uint64_t> packets_sent;
-  RTCStatsMember<uint64_t> bytes_sent;
+  absl::optional<uint64_t> packets_sent;
+  absl::optional<uint64_t> bytes_sent;
 
  protected:
   RTCSentRtpStreamStats(std::string id, Timestamp timestamp);
@@ -221,51 +222,51 @@ class RTC_EXPORT RTCInboundRtpStreamStats final
   RTCInboundRtpStreamStats(std::string id, Timestamp timestamp);
   ~RTCInboundRtpStreamStats() override;
 
-  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_bytes_received;
-  RTCStatsMember<uint64_t> fec_packets_discarded;
+  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.
-  RTCStatsMember<uint32_t> fec_ssrc;
-  RTCStatsMember<uint64_t> bytes_received;
-  RTCStatsMember<uint64_t> header_bytes_received;
+  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.
-  RTCStatsMember<uint64_t> retransmitted_packets_received;
-  RTCStatsMember<uint64_t> retransmitted_bytes_received;
-  RTCStatsMember<uint32_t> rtx_ssrc;
-
-  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;
+  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.
-  RTCStatsMember<uint32_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;
+  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
@@ -277,43 +278,43 @@ class RTC_EXPORT RTCInboundRtpStreamStats final
   // 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.
-  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;
+  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
-  RTCStatsMember<std::string> content_type;
+  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?
-  RTCStatsMember<double> estimated_playout_timestamp;
+  absl::optional<double> estimated_playout_timestamp;
   // Only defined for video.
   // In JavaScript, this is only exposed if HW exposure is allowed.
-  RTCStatsMember<std::string> decoder_implementation;
+  absl::optional<std::string> decoder_implementation;
   // FIR and PLI counts are only defined for |kind == "video"|.
-  RTCStatsMember<uint32_t> fir_count;
-  RTCStatsMember<uint32_t> pli_count;
-  RTCStatsMember<uint32_t> nack_count;
-  RTCStatsMember<uint64_t> qp_sum;
+  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.
-  RTCStatsMember<std::string> goog_timing_frame_info;
+  absl::optional<std::string> goog_timing_frame_info;
   // In JavaScript, this is only exposed if HW exposure is allowed.
-  RTCStatsMember<bool> power_efficient_decoder;
+  absl::optional<bool> power_efficient_decoder;
 
   // The following metrics are NOT exposed to JavaScript. We should consider
   // standardizing or removing them.
-  RTCStatsMember<uint64_t> jitter_buffer_flushes;
-  RTCStatsMember<uint64_t> delayed_packet_outage_samples;
-  RTCStatsMember<double> relative_packet_arrival_delay;
-  RTCStatsMember<uint32_t> interruption_count;
-  RTCStatsMember<double> total_interruption_duration;
-  RTCStatsMember<double> min_playout_delay;
+  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*
@@ -324,46 +325,46 @@ class RTC_EXPORT RTCOutboundRtpStreamStats final
   RTCOutboundRtpStreamStats(std::string id, Timestamp timestamp);
   ~RTCOutboundRtpStreamStats() override;
 
-  RTCStatsMember<std::string> media_source_id;
-  RTCStatsMember<std::string> remote_id;
-  RTCStatsMember<std::string> mid;
-  RTCStatsMember<std::string> rid;
-  RTCStatsMember<uint64_t> retransmitted_packets_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;
-  RTCStatsMember<std::string> quality_limitation_reason;
-  RTCStatsMember<std::map<std::string, double>> quality_limitation_durations;
+  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
-  RTCStatsMember<uint32_t> quality_limitation_resolution_changes;
+  absl::optional<uint32_t> quality_limitation_resolution_changes;
   // https://w3c.github.io/webrtc-provisional-stats/#dom-rtcoutboundrtpstreamstats-contenttype
-  RTCStatsMember<std::string> content_type;
+  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.
-  RTCStatsMember<std::string> encoder_implementation;
+  absl::optional<std::string> 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;
+  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.
-  RTCStatsMember<bool> power_efficient_encoder;
-  RTCStatsMember<std::string> scalability_mode;
+  absl::optional<bool> power_efficient_encoder;
+  absl::optional<std::string> scalability_mode;
 
   // RTX ssrc. Only present if RTX is negotiated.
-  RTCStatsMember<uint32_t> rtx_ssrc;
+  absl::optional<uint32_t> rtx_ssrc;
 };
 
 // https://w3c.github.io/webrtc-stats/#remoteinboundrtpstats-dict*
@@ -374,11 +375,11 @@ class RTC_EXPORT RTCRemoteInboundRtpStreamStats final
   RTCRemoteInboundRtpStreamStats(std::string id, Timestamp timestamp);
   ~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;
+  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*
@@ -389,12 +390,12 @@ class RTC_EXPORT RTCRemoteOutboundRtpStreamStats final
   RTCRemoteOutboundRtpStreamStats(std::string id, Timestamp timestamp);
   ~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;
+  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
@@ -403,8 +404,8 @@ class RTC_EXPORT RTCMediaSourceStats : public RTCStats {
   WEBRTC_RTCSTATS_DECL();
   ~RTCMediaSourceStats() override;
 
-  RTCStatsMember<std::string> track_identifier;
-  RTCStatsMember<std::string> kind;
+  absl::optional<std::string> track_identifier;
+  absl::optional<std::string> kind;
 
  protected:
   RTCMediaSourceStats(std::string id, Timestamp timestamp);
@@ -417,11 +418,11 @@ class RTC_EXPORT RTCAudioSourceStats final : public RTCMediaSourceStats {
   RTCAudioSourceStats(std::string id, Timestamp timestamp);
   ~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;
+  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
@@ -431,10 +432,10 @@ class RTC_EXPORT RTCVideoSourceStats final : public RTCMediaSourceStats {
   RTCVideoSourceStats(std::string id, Timestamp timestamp);
   ~RTCVideoSourceStats() override;
 
-  RTCStatsMember<uint32_t> width;
-  RTCStatsMember<uint32_t> height;
-  RTCStatsMember<uint32_t> frames;
-  RTCStatsMember<double> frames_per_second;
+  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*
@@ -444,23 +445,23 @@ class RTC_EXPORT RTCTransportStats final : public RTCStats {
   RTCTransportStats(std::string id, Timestamp timestamp);
   ~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;
-  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;
+  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*
@@ -470,12 +471,12 @@ class RTC_EXPORT RTCAudioPlayoutStats final : public RTCStats {
   RTCAudioPlayoutStats(const std::string& id, Timestamp timestamp);
   ~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;
+  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