diff --git a/api/stats/rtc_stats.h b/api/stats/rtc_stats.h
index 678108109a..74e7fc4d8e 100644
--- a/api/stats/rtc_stats.h
+++ b/api/stats/rtc_stats.h
@@ -20,6 +20,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/types/optional.h"
 #include "api/stats/attribute.h"
 #include "api/units/timestamp.h"
 #include "rtc_base/checks.h"
@@ -38,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;
@@ -51,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:
@@ -72,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;
       }
@@ -135,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/api/stats/rtcstats_objects.h b/api/stats/rtcstats_objects.h
index 351c2cbefe..9f51f56cc5 100644
--- a/api/stats/rtcstats_objects.h
+++ b/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;
+  absl::optional<uint64_t> retransmitted_packets_received;
+  absl::optional<uint64_t> retransmitted_bytes_received;
+  absl::optional<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<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
diff --git a/pc/BUILD.gn b/pc/BUILD.gn
index 2edbf9d63a..1f814cb1aa 100644
--- a/pc/BUILD.gn
+++ b/pc/BUILD.gn
@@ -970,6 +970,7 @@ rtc_source_set("rtc_stats_traversal") {
     "../api:scoped_refptr",
     "../rtc_base:checks",
   ]
+  absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
 }
 
 rtc_source_set("sdp_offer_answer") {
diff --git a/pc/rtc_stats_collector_unittest.cc b/pc/rtc_stats_collector_unittest.cc
index 61b3bca1db..03512bbcde 100644
--- a/pc/rtc_stats_collector_unittest.cc
+++ b/pc/rtc_stats_collector_unittest.cc
@@ -23,6 +23,7 @@
 #include <vector>
 
 #include "absl/strings/str_replace.h"
+#include "absl/types/optional.h"
 #include "api/candidate.h"
 #include "api/dtls_transport_interface.h"
 #include "api/media_stream_interface.h"
@@ -3723,7 +3724,7 @@ class RTCTestStats : public RTCStats {
   RTCTestStats(const std::string& id, Timestamp timestamp)
       : RTCStats(id, timestamp) {}
 
-  RTCStatsMember<int32_t> dummy_stat;
+  absl::optional<int32_t> dummy_stat;
 };
 
 WEBRTC_RTCSTATS_IMPL(RTCTestStats,
diff --git a/pc/rtc_stats_integrationtest.cc b/pc/rtc_stats_integrationtest.cc
index 002f9d34b5..de8e6e3f67 100644
--- a/pc/rtc_stats_integrationtest.cc
+++ b/pc/rtc_stats_integrationtest.cc
@@ -18,6 +18,7 @@
 
 #include "absl/algorithm/container.h"
 #include "absl/strings/match.h"
+#include "absl/types/optional.h"
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/audio_options.h"
@@ -212,14 +213,14 @@ class RTCStatsVerifier {
   }
 
   template <typename T>
-  void MarkAttributeTested(const RTCStatsMember<T>& field,
+  void MarkAttributeTested(const absl::optional<T>& field,
                            bool test_successful) {
     untested_attribute_names_.erase(stats_->GetAttribute(field).name());
     all_tests_successful_ &= test_successful;
   }
 
   template <typename T>
-  void TestAttributeIsDefined(const RTCStatsMember<T>& field) {
+  void TestAttributeIsDefined(const absl::optional<T>& field) {
     EXPECT_TRUE(field.has_value())
         << stats_->type() << "." << stats_->GetAttribute(field).name() << "["
         << stats_->id() << "] was undefined.";
@@ -227,7 +228,7 @@ class RTCStatsVerifier {
   }
 
   template <typename T>
-  void TestAttributeIsUndefined(const RTCStatsMember<T>& field) {
+  void TestAttributeIsUndefined(const absl::optional<T>& field) {
     Attribute attribute = stats_->GetAttribute(field);
     EXPECT_FALSE(field.has_value())
         << stats_->type() << "." << attribute.name() << "[" << stats_->id()
@@ -236,7 +237,7 @@ class RTCStatsVerifier {
   }
 
   template <typename T>
-  void TestAttributeIsPositive(const RTCStatsMember<T>& field) {
+  void TestAttributeIsPositive(const absl::optional<T>& field) {
     Attribute attribute = stats_->GetAttribute(field);
     EXPECT_TRUE(field.has_value()) << stats_->type() << "." << attribute.name()
                                    << "[" << stats_->id() << "] was undefined.";
@@ -252,7 +253,7 @@ class RTCStatsVerifier {
   }
 
   template <typename T>
-  void TestAttributeIsNonNegative(const RTCStatsMember<T>& field) {
+  void TestAttributeIsNonNegative(const absl::optional<T>& field) {
     Attribute attribute = stats_->GetAttribute(field);
     EXPECT_TRUE(field.has_value()) << stats_->type() << "." << attribute.name()
                                    << "[" << stats_->id() << "] was undefined.";
@@ -268,13 +269,13 @@ class RTCStatsVerifier {
   }
 
   template <typename T>
-  void TestAttributeIsIDReference(const RTCStatsMember<T>& field,
+  void TestAttributeIsIDReference(const absl::optional<T>& field,
                                   const char* expected_type) {
     TestAttributeIsIDReference(field, expected_type, false);
   }
 
   template <typename T>
-  void TestAttributeIsOptionalIDReference(const RTCStatsMember<T>& field,
+  void TestAttributeIsOptionalIDReference(const absl::optional<T>& field,
                                           const char* expected_type) {
     TestAttributeIsIDReference(field, expected_type, true);
   }
@@ -291,7 +292,7 @@ class RTCStatsVerifier {
 
  private:
   template <typename T>
-  void TestAttributeIsIDReference(const RTCStatsMember<T>& field,
+  void TestAttributeIsIDReference(const absl::optional<T>& field,
                                   const char* expected_type,
                                   bool optional) {
     if (optional && !field.has_value()) {
diff --git a/pc/rtc_stats_traversal.cc b/pc/rtc_stats_traversal.cc
index dfd0570b8f..e9d11b5ae5 100644
--- a/pc/rtc_stats_traversal.cc
+++ b/pc/rtc_stats_traversal.cc
@@ -15,6 +15,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/types/optional.h"
 #include "api/stats/rtcstats_objects.h"
 #include "rtc_base/checks.h"
 
@@ -42,7 +43,7 @@ void TraverseAndTakeVisitedStats(RTCStatsReport* report,
   }
 }
 
-void AddIdIfDefined(const RTCStatsMember<std::string>& id,
+void AddIdIfDefined(const absl::optional<std::string>& id,
                     std::vector<const std::string*>* neighbor_ids) {
   if (id.has_value())
     neighbor_ids->push_back(&(*id));
diff --git a/stats/BUILD.gn b/stats/BUILD.gn
index 76edc441cb..1ca584d6a2 100644
--- a/stats/BUILD.gn
+++ b/stats/BUILD.gn
@@ -45,6 +45,7 @@ rtc_library("rtc_stats_test_utils") {
     "../rtc_base:checks",
     "../rtc_base/system:rtc_export",
   ]
+  absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
 }
 
 if (rtc_include_tests && !build_with_chromium) {
@@ -74,5 +75,7 @@ if (rtc_include_tests && !build_with_chromium) {
         "//testing/android/native_test:native_test_support",
       ]
     }
+
+    absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
   }
 }
diff --git a/stats/rtc_stats_report_unittest.cc b/stats/rtc_stats_report_unittest.cc
index b3ac0a2db4..f11ff52e53 100644
--- a/stats/rtc_stats_report_unittest.cc
+++ b/stats/rtc_stats_report_unittest.cc
@@ -10,6 +10,7 @@
 
 #include "api/stats/rtc_stats_report.h"
 
+#include "absl/types/optional.h"
 #include "api/stats/attribute.h"
 #include "api/stats/rtc_stats.h"
 #include "rtc_base/checks.h"
@@ -24,7 +25,7 @@ class RTCTestStats1 : public RTCStats {
   RTCTestStats1(const std::string& id, Timestamp timestamp)
       : RTCStats(id, timestamp) {}
 
-  RTCStatsMember<int32_t> integer;
+  absl::optional<int32_t> integer;
 };
 
 WEBRTC_RTCSTATS_IMPL(RTCTestStats1,
@@ -39,7 +40,7 @@ class RTCTestStats2 : public RTCStats {
   RTCTestStats2(const std::string& id, Timestamp timestamp)
       : RTCStats(id, timestamp) {}
 
-  RTCStatsMember<double> number;
+  absl::optional<double> number;
 };
 
 WEBRTC_RTCSTATS_IMPL(RTCTestStats2,
@@ -54,7 +55,7 @@ class RTCTestStats3 : public RTCStats {
   RTCTestStats3(const std::string& id, Timestamp timestamp)
       : RTCStats(id, timestamp) {}
 
-  RTCStatsMember<std::string> string;
+  absl::optional<std::string> string;
 };
 
 WEBRTC_RTCSTATS_IMPL(RTCTestStats3,
diff --git a/stats/rtc_stats_unittest.cc b/stats/rtc_stats_unittest.cc
index 1098f04b65..555360f07f 100644
--- a/stats/rtc_stats_unittest.cc
+++ b/stats/rtc_stats_unittest.cc
@@ -15,6 +15,7 @@
 #include <cstring>
 #include <iostream>
 
+#include "absl/types/optional.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/strings/json.h"
 #include "stats/test/rtc_test_stats.h"
@@ -46,7 +47,7 @@ class RTCChildStats : public RTCStats {
   RTCChildStats(const std::string& id, Timestamp timestamp)
       : RTCStats(id, timestamp) {}
 
-  RTCStatsMember<int32_t> child_int;
+  absl::optional<int32_t> child_int;
 };
 
 WEBRTC_RTCSTATS_IMPL(RTCChildStats,
@@ -61,7 +62,7 @@ class RTCGrandChildStats : public RTCChildStats {
   RTCGrandChildStats(const std::string& id, Timestamp timestamp)
       : RTCChildStats(id, timestamp) {}
 
-  RTCStatsMember<int32_t> grandchild_int;
+  absl::optional<int32_t> grandchild_int;
 };
 
 WEBRTC_RTCSTATS_IMPL(RTCGrandChildStats,
diff --git a/stats/test/rtc_test_stats.h b/stats/test/rtc_test_stats.h
index 05c0904c02..ff1a06f97c 100644
--- a/stats/test/rtc_test_stats.h
+++ b/stats/test/rtc_test_stats.h
@@ -16,6 +16,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/types/optional.h"
 #include "api/stats/rtc_stats.h"
 #include "rtc_base/system/rtc_export.h"
 
@@ -27,22 +28,22 @@ class RTC_EXPORT RTCTestStats : public RTCStats {
   RTCTestStats(const std::string& id, Timestamp timestamp);
   ~RTCTestStats() override;
 
-  RTCStatsMember<bool> m_bool;
-  RTCStatsMember<int32_t> m_int32;
-  RTCStatsMember<uint32_t> m_uint32;
-  RTCStatsMember<int64_t> m_int64;
-  RTCStatsMember<uint64_t> m_uint64;
-  RTCStatsMember<double> m_double;
-  RTCStatsMember<std::string> m_string;
-  RTCStatsMember<std::vector<bool>> m_sequence_bool;
-  RTCStatsMember<std::vector<int32_t>> m_sequence_int32;
-  RTCStatsMember<std::vector<uint32_t>> m_sequence_uint32;
-  RTCStatsMember<std::vector<int64_t>> m_sequence_int64;
-  RTCStatsMember<std::vector<uint64_t>> m_sequence_uint64;
-  RTCStatsMember<std::vector<double>> m_sequence_double;
-  RTCStatsMember<std::vector<std::string>> m_sequence_string;
-  RTCStatsMember<std::map<std::string, uint64_t>> m_map_string_uint64;
-  RTCStatsMember<std::map<std::string, double>> m_map_string_double;
+  absl::optional<bool> m_bool;
+  absl::optional<int32_t> m_int32;
+  absl::optional<uint32_t> m_uint32;
+  absl::optional<int64_t> m_int64;
+  absl::optional<uint64_t> m_uint64;
+  absl::optional<double> m_double;
+  absl::optional<std::string> m_string;
+  absl::optional<std::vector<bool>> m_sequence_bool;
+  absl::optional<std::vector<int32_t>> m_sequence_int32;
+  absl::optional<std::vector<uint32_t>> m_sequence_uint32;
+  absl::optional<std::vector<int64_t>> m_sequence_int64;
+  absl::optional<std::vector<uint64_t>> m_sequence_uint64;
+  absl::optional<std::vector<double>> m_sequence_double;
+  absl::optional<std::vector<std::string>> m_sequence_string;
+  absl::optional<std::map<std::string, uint64_t>> m_map_string_uint64;
+  absl::optional<std::map<std::string, double>> m_map_string_double;
 };
 
 }  // namespace webrtc