Merging upstream version 126.0.

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

4 files changed, 348 insertions, 298 deletions

diff --git a/third_party/libwebrtc/api/stats/attribute.h b/third_party/libwebrtc/api/stats/attribute.h
new file mode 100644
index 0000000000..09211f469c
--- /dev/null
+++ b/third_party/libwebrtc/api/stats/attribute.h
@@ -0,0 +1,96 @@
+/*
+ *  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/variant.h"
+#include "api/stats/rtc_stats_member.h"
+#include "rtc_base/system/rtc_export.h"
+
+namespace webrtc {
+
+// A light-weight wrapper of an RTCStats attribute (an individual metric).
+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>>*>
+      StatVariant;
+
+  template <typename T>
+  explicit Attribute(const char* name, const RTCStatsMember<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 RTCStatsMember<T>*>(attribute_);
+  }
+  template <typename T>
+  absl::optional<T> as_optional() const {
+    RTC_CHECK(holds_alternative<T>());
+    if (!has_value()) {
+      return absl::nullopt;
+    }
+    return absl::optional<T>(get<T>());
+  }
+  template <typename T>
+  const T& get() const {
+    RTC_CHECK(holds_alternative<T>());
+    RTC_CHECK(has_value());
+    return absl::get<const RTCStatsMember<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_
diff --git a/third_party/libwebrtc/api/stats/rtc_stats.h b/third_party/libwebrtc/api/stats/rtc_stats.h
index 6cc39a309f..edd293f5c9 100644
--- a/third_party/libwebrtc/api/stats/rtc_stats.h
+++ b/third_party/libwebrtc/api/stats/rtc_stats.h
@@ -20,7 +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"
@@ -28,8 +29,6 @@
 
 namespace webrtc {
 
-class RTCStatsMemberInterface;
-
 // Abstract base class for RTCStats-derived dictionaries, see
 // https://w3c.github.io/webrtc-stats/.
 //
@@ -40,8 +39,8 @@ class RTCStatsMemberInterface;
 // 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:
+// Derived classes list their dictionary attributes (RTCStatsMember<T> to soon
+// be replaced by absl::optional<T>) as public fields, allowing the following:
 //
 // RTCFooStats foo("fooId", Timestamp::Micros(GetCurrentTime()));
 // foo.bar = 42;
@@ -49,17 +48,18 @@ class RTCStatsMemberInterface;
 // foo.baz->push_back("hello world");
 // uint32_t x = *foo.bar;
 //
-// Pointers to all the members are available with `Members`, allowing iteration:
+// Pointers to all the attributes are available with `Attributes()`, allowing
+// iteration:
 //
-// for (const RTCStatsMemberInterface* member : foo.Members()) {
-//   printf("%s = %s\n", member->name(), member->ValueToString().c_str());
+// for (const auto& attribute : foo.Attributes()) {
+//   printf("%s = %s\n", attribute.name(), attribute.ValueToString().c_str());
 // }
 class RTC_EXPORT RTCStats {
  public:
   RTCStats(const std::string& id, Timestamp timestamp)
       : id_(id), timestamp_(timestamp) {}
-
-  virtual ~RTCStats() {}
+  RTCStats(const RTCStats& other);
+  virtual ~RTCStats();
 
   virtual std::unique_ptr<RTCStats> copy() const = 0;
 
@@ -69,18 +69,30 @@ class RTC_EXPORT RTCStats {
 
   // 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;
+  // 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 RTCStatsMember<T>& stat) const {
+    for (const auto& attribute : Attributes()) {
+      if (!attribute.holds_alternative<T>()) {
+        continue;
+      }
+      if (absl::get<const RTCStatsMember<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
-  // member values. Timestamps are not compared. These operators are exposed for
-  // testing.
+  // 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 members (names and values).
+  // 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
@@ -92,12 +104,8 @@ class RTC_EXPORT RTCStats {
   }
 
  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;
+  virtual std::vector<Attribute> AttributesImpl(
+      size_t additional_capacity) const;
 
   std::string const id_;
   Timestamp timestamp_;
@@ -109,9 +117,8 @@ class RTC_EXPORT RTCStats {
 //
 // 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.
+// `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
@@ -144,247 +151,45 @@ class RTC_EXPORT RTCStats {
 //         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);                             \
-  }                                                                         \
+#define WEBRTC_RTCSTATS_DECL()                                              \
+ protected:                                                                 \
+  std::vector<webrtc::Attribute> AttributesImpl(size_t additional_capacity) \
+      const override;                                                       \
                                                                             \
-  const char* this_class::type() const {                                    \
-    return this_class::kType;                                               \
-  }                                                                         \
+ public:                                                                    \
+  static const char kType[];                                                \
                                                                             \
-  std::vector<const webrtc::RTCStatsMemberInterface*>                       \
-  this_class::MembersOfThisObjectAndAncestors(                              \
-      size_t local_var_additional_capacity) const {                         \
-    return parent_class::MembersOfThisObjectAndAncestors(0);                \
-  }
-
-// 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;
-  // 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();
-  }
-
-  // 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 { 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_);
-  }
+  std::unique_ptr<webrtc::RTCStats> copy() const override;                  \
+  const char* type() const override
 
- protected:
-  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_;
+#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;                                                        \
   }
 
- 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);
-
 }  // namespace webrtc
 
 #endif  // API_STATS_RTC_STATS_H_
diff --git a/third_party/libwebrtc/api/stats/rtc_stats_member.h b/third_party/libwebrtc/api/stats/rtc_stats_member.h
new file mode 100644
index 0000000000..9039569ede
--- /dev/null
+++ b/third_party/libwebrtc/api/stats/rtc_stats_member.h
@@ -0,0 +1,185 @@
+/*
+ *  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 c28b635660..351c2cbefe 100644
--- a/third_party/libwebrtc/api/stats/rtcstats_objects.h
+++ b/third_party/libwebrtc/api/stats/rtcstats_objects.h
@@ -27,9 +27,7 @@ namespace webrtc {
 class RTC_EXPORT RTCCertificateStats final : public RTCStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
   RTCCertificateStats(std::string id, Timestamp timestamp);
-  RTCCertificateStats(const RTCCertificateStats& other);
   ~RTCCertificateStats() override;
 
   RTCStatsMember<std::string> fingerprint;
@@ -42,9 +40,7 @@ class RTC_EXPORT RTCCertificateStats final : public RTCStats {
 class RTC_EXPORT RTCCodecStats final : public RTCStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
   RTCCodecStats(std::string id, Timestamp timestamp);
-  RTCCodecStats(const RTCCodecStats& other);
   ~RTCCodecStats() override;
 
   RTCStatsMember<std::string> transport_id;
@@ -59,9 +55,7 @@ class RTC_EXPORT RTCCodecStats final : public RTCStats {
 class RTC_EXPORT RTCDataChannelStats final : public RTCStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
   RTCDataChannelStats(std::string id, Timestamp timestamp);
-  RTCDataChannelStats(const RTCDataChannelStats& other);
   ~RTCDataChannelStats() override;
 
   RTCStatsMember<std::string> label;
@@ -78,9 +72,7 @@ class RTC_EXPORT RTCDataChannelStats final : public RTCStats {
 class RTC_EXPORT RTCIceCandidatePairStats final : public RTCStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
   RTCIceCandidatePairStats(std::string id, Timestamp timestamp);
-  RTCIceCandidatePairStats(const RTCIceCandidatePairStats& other);
   ~RTCIceCandidatePairStats() override;
 
   RTCStatsMember<std::string> transport_id;
@@ -118,8 +110,6 @@ class RTC_EXPORT RTCIceCandidatePairStats final : public RTCStats {
 class RTC_EXPORT RTCIceCandidateStats : public RTCStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
-  RTCIceCandidateStats(const RTCIceCandidateStats& other);
   ~RTCIceCandidateStats() override;
 
   RTCStatsMember<std::string> transport_id;
@@ -175,9 +165,7 @@ class RTC_EXPORT RTCRemoteIceCandidateStats final
 class RTC_EXPORT RTCPeerConnectionStats final : public RTCStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
   RTCPeerConnectionStats(std::string id, Timestamp timestamp);
-  RTCPeerConnectionStats(const RTCPeerConnectionStats& other);
   ~RTCPeerConnectionStats() override;
 
   RTCStatsMember<uint32_t> data_channels_opened;
@@ -188,8 +176,6 @@ class RTC_EXPORT RTCPeerConnectionStats final : public RTCStats {
 class RTC_EXPORT RTCRtpStreamStats : public RTCStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
-  RTCRtpStreamStats(const RTCRtpStreamStats& other);
   ~RTCRtpStreamStats() override;
 
   RTCStatsMember<uint32_t> ssrc;
@@ -205,8 +191,6 @@ class RTC_EXPORT RTCRtpStreamStats : public RTCStats {
 class RTC_EXPORT RTCReceivedRtpStreamStats : public RTCRtpStreamStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
-  RTCReceivedRtpStreamStats(const RTCReceivedRtpStreamStats& other);
   ~RTCReceivedRtpStreamStats() override;
 
   RTCStatsMember<double> jitter;
@@ -220,8 +204,6 @@ class RTC_EXPORT RTCReceivedRtpStreamStats : public RTCRtpStreamStats {
 class RTC_EXPORT RTCSentRtpStreamStats : public RTCRtpStreamStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
-  RTCSentRtpStreamStats(const RTCSentRtpStreamStats& other);
   ~RTCSentRtpStreamStats() override;
 
   RTCStatsMember<uint64_t> packets_sent;
@@ -236,9 +218,7 @@ class RTC_EXPORT RTCInboundRtpStreamStats final
     : public RTCReceivedRtpStreamStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
   RTCInboundRtpStreamStats(std::string id, Timestamp timestamp);
-  RTCInboundRtpStreamStats(const RTCInboundRtpStreamStats& other);
   ~RTCInboundRtpStreamStats() override;
 
   RTCStatsMember<std::string> playout_id;
@@ -341,9 +321,7 @@ class RTC_EXPORT RTCOutboundRtpStreamStats final
     : public RTCSentRtpStreamStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
   RTCOutboundRtpStreamStats(std::string id, Timestamp timestamp);
-  RTCOutboundRtpStreamStats(const RTCOutboundRtpStreamStats& other);
   ~RTCOutboundRtpStreamStats() override;
 
   RTCStatsMember<std::string> media_source_id;
@@ -393,9 +371,7 @@ class RTC_EXPORT RTCRemoteInboundRtpStreamStats final
     : public RTCReceivedRtpStreamStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
   RTCRemoteInboundRtpStreamStats(std::string id, Timestamp timestamp);
-  RTCRemoteInboundRtpStreamStats(const RTCRemoteInboundRtpStreamStats& other);
   ~RTCRemoteInboundRtpStreamStats() override;
 
   RTCStatsMember<std::string> local_id;
@@ -410,9 +386,7 @@ class RTC_EXPORT RTCRemoteOutboundRtpStreamStats final
     : public RTCSentRtpStreamStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
   RTCRemoteOutboundRtpStreamStats(std::string id, Timestamp timestamp);
-  RTCRemoteOutboundRtpStreamStats(const RTCRemoteOutboundRtpStreamStats& other);
   ~RTCRemoteOutboundRtpStreamStats() override;
 
   RTCStatsMember<std::string> local_id;
@@ -427,8 +401,6 @@ class RTC_EXPORT RTCRemoteOutboundRtpStreamStats final
 class RTC_EXPORT RTCMediaSourceStats : public RTCStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
-  RTCMediaSourceStats(const RTCMediaSourceStats& other);
   ~RTCMediaSourceStats() override;
 
   RTCStatsMember<std::string> track_identifier;
@@ -442,9 +414,7 @@ class RTC_EXPORT RTCMediaSourceStats : public RTCStats {
 class RTC_EXPORT RTCAudioSourceStats final : public RTCMediaSourceStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
   RTCAudioSourceStats(std::string id, Timestamp timestamp);
-  RTCAudioSourceStats(const RTCAudioSourceStats& other);
   ~RTCAudioSourceStats() override;
 
   RTCStatsMember<double> audio_level;
@@ -458,9 +428,7 @@ class RTC_EXPORT RTCAudioSourceStats final : public RTCMediaSourceStats {
 class RTC_EXPORT RTCVideoSourceStats final : public RTCMediaSourceStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
   RTCVideoSourceStats(std::string id, Timestamp timestamp);
-  RTCVideoSourceStats(const RTCVideoSourceStats& other);
   ~RTCVideoSourceStats() override;
 
   RTCStatsMember<uint32_t> width;
@@ -473,9 +441,7 @@ class RTC_EXPORT RTCVideoSourceStats final : public RTCMediaSourceStats {
 class RTC_EXPORT RTCTransportStats final : public RTCStats {
  public:
   WEBRTC_RTCSTATS_DECL();
-
   RTCTransportStats(std::string id, Timestamp timestamp);
-  RTCTransportStats(const RTCTransportStats& other);
   ~RTCTransportStats() override;
 
   RTCStatsMember<uint64_t> bytes_sent;
@@ -501,9 +467,7 @@ class RTC_EXPORT RTCTransportStats final : public RTCStats {
 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;