diff --git a/modules/rtp_rtcp/source/rtcp_receiver.cc b/modules/rtp_rtcp/source/rtcp_receiver.cc
index a9ec2a10a0..da59fe0de0 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver.cc
+++ b/modules/rtp_rtcp/source/rtcp_receiver.cc
@@ -714,7 +714,6 @@ void RTCPReceiver::HandleSdes(const CommonHeader& rtcp_block,
   }
 
   for (const rtcp::Sdes::Chunk& chunk : sdes.chunks()) {
-    received_cnames_[chunk.ssrc] = chunk.cname;
     if (cname_callback_)
       cname_callback_->OnCname(chunk.ssrc, chunk.cname);
   }
@@ -778,7 +777,6 @@ void RTCPReceiver::HandleBye(const CommonHeader& rtcp_block) {
     tmmbr_info->ready_for_delete = true;
 
   last_fir_.erase(bye.sender_ssrc());
-  received_cnames_.erase(bye.sender_ssrc());
   auto it = received_rrtrs_ssrc_it_.find(bye.sender_ssrc());
   if (it != received_rrtrs_ssrc_it_.end()) {
     received_rrtrs_.erase(it->second);
@@ -1169,20 +1167,6 @@ void RTCPReceiver::TriggerCallbacksFromRtcpPacket(
   }
 }
 
-int32_t RTCPReceiver::CNAME(uint32_t remoteSSRC,
-                            char cName[RTCP_CNAME_SIZE]) const {
-  RTC_DCHECK(cName);
-
-  MutexLock lock(&rtcp_receiver_lock_);
-  auto received_cname_it = received_cnames_.find(remoteSSRC);
-  if (received_cname_it == received_cnames_.end())
-    return -1;
-
-  size_t length = received_cname_it->second.copy(cName, RTCP_CNAME_SIZE - 1);
-  cName[length] = 0;
-  return 0;
-}
-
 std::vector<rtcp::TmmbItem> RTCPReceiver::TmmbrReceived() {
   MutexLock lock(&rtcp_receiver_lock_);
   std::vector<rtcp::TmmbItem> candidates;
diff --git a/modules/rtp_rtcp/source/rtcp_receiver.h b/modules/rtp_rtcp/source/rtcp_receiver.h
index d735653f41..e5dc915444 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver.h
+++ b/modules/rtp_rtcp/source/rtcp_receiver.h
@@ -67,9 +67,6 @@ class RTCPReceiver final {
   void SetRemoteSSRC(uint32_t ssrc);
   uint32_t RemoteSSRC() const;
 
-  // Get received cname.
-  int32_t CNAME(uint32_t remote_ssrc, char cname[RTCP_CNAME_SIZE]) const;
-
   // Get received NTP.
   bool NTP(uint32_t* received_ntp_secs,
            uint32_t* received_ntp_frac,
@@ -262,8 +259,6 @@ class RTCPReceiver final {
   ReportBlockMap received_report_blocks_ RTC_GUARDED_BY(rtcp_receiver_lock_);
   std::map<uint32_t, LastFirStatus> last_fir_
       RTC_GUARDED_BY(rtcp_receiver_lock_);
-  std::map<uint32_t, std::string> received_cnames_
-      RTC_GUARDED_BY(rtcp_receiver_lock_);
 
   // The last time we received an RTCP Report block for this module.
   Timestamp last_received_rb_ RTC_GUARDED_BY(rtcp_receiver_lock_) =
diff --git a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
index 1a1d94a4f0..a512b0d8e2 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
@@ -648,33 +648,6 @@ TEST(RtcpReceiverTest, InjectSdesWithOneChunk) {
 
   EXPECT_CALL(callback, OnCname(kSenderSsrc, StrEq(kCname)));
   receiver.IncomingPacket(sdes.Build());
-
-  char cName[RTCP_CNAME_SIZE];
-  EXPECT_EQ(0, receiver.CNAME(kSenderSsrc, cName));
-  EXPECT_EQ(0, strncmp(cName, kCname, RTCP_CNAME_SIZE));
-}
-
-TEST(RtcpReceiverTest, InjectByePacket_RemovesCname) {
-  ReceiverMocks mocks;
-  RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
-  receiver.SetRemoteSSRC(kSenderSsrc);
-
-  const char kCname[] = "alice@host";
-  rtcp::Sdes sdes;
-  sdes.AddCName(kSenderSsrc, kCname);
-
-  receiver.IncomingPacket(sdes.Build());
-
-  char cName[RTCP_CNAME_SIZE];
-  EXPECT_EQ(0, receiver.CNAME(kSenderSsrc, cName));
-
-  // Verify that BYE removes the CNAME.
-  rtcp::Bye bye;
-  bye.SetSenderSsrc(kSenderSsrc);
-
-  receiver.IncomingPacket(bye.Build());
-
-  EXPECT_EQ(-1, receiver.CNAME(kSenderSsrc, cName));
 }
 
 TEST(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) {
diff --git a/modules/rtp_rtcp/source/rtcp_sender.cc b/modules/rtp_rtcp/source/rtcp_sender.cc
index c4679e6534..8b519b5c7d 100644
--- a/modules/rtp_rtcp/source/rtcp_sender.cc
+++ b/modules/rtp_rtcp/source/rtcp_sender.cc
@@ -273,15 +273,6 @@ bool RTCPSender::TMMBR() const {
   return IsFlagPresent(RTCPPacketType::kRtcpTmmbr);
 }
 
-void RTCPSender::SetTMMBRStatus(bool enable) {
-  MutexLock lock(&mutex_rtcp_sender_);
-  if (enable) {
-    SetFlag(RTCPPacketType::kRtcpTmmbr, false);
-  } else {
-    ConsumeFlag(RTCPPacketType::kRtcpTmmbr, true);
-  }
-}
-
 void RTCPSender::SetMaxRtpPacketSize(size_t max_packet_size) {
   MutexLock lock(&mutex_rtcp_sender_);
   max_packet_size_ = max_packet_size;
@@ -330,31 +321,6 @@ int32_t RTCPSender::SetCNAME(const char* c_name) {
   return 0;
 }
 
-int32_t RTCPSender::AddMixedCNAME(uint32_t SSRC, const char* c_name) {
-  RTC_DCHECK(c_name);
-  RTC_DCHECK_LT(strlen(c_name), RTCP_CNAME_SIZE);
-  MutexLock lock(&mutex_rtcp_sender_);
-  // One spot is reserved for ssrc_/cname_.
-  // TODO(danilchap): Add support for more than 30 contributes by sending
-  // several sdes packets.
-  if (csrc_cnames_.size() >= rtcp::Sdes::kMaxNumberOfChunks - 1)
-    return -1;
-
-  csrc_cnames_[SSRC] = c_name;
-  return 0;
-}
-
-int32_t RTCPSender::RemoveMixedCNAME(uint32_t SSRC) {
-  MutexLock lock(&mutex_rtcp_sender_);
-  auto it = csrc_cnames_.find(SSRC);
-
-  if (it == csrc_cnames_.end())
-    return -1;
-
-  csrc_cnames_.erase(it);
-  return 0;
-}
-
 bool RTCPSender::TimeToSendRTCPReport(bool sendKeyframeBeforeRTP) const {
   /*
       For audio we use a configurable interval (default: 5 seconds)
@@ -465,10 +431,6 @@ void RTCPSender::BuildSDES(const RtcpContext& ctx, PacketSender& sender) {
 
   rtcp::Sdes sdes;
   sdes.AddCName(ssrc_, cname_);
-
-  for (const auto& it : csrc_cnames_)
-    RTC_CHECK(sdes.AddCName(it.first, it.second));
-
   sender.AppendPacket(sdes);
 }
 
diff --git a/modules/rtp_rtcp/source/rtcp_sender.h b/modules/rtp_rtcp/source/rtcp_sender.h
index 10211435e9..463666a22a 100644
--- a/modules/rtp_rtcp/source/rtcp_sender.h
+++ b/modules/rtp_rtcp/source/rtcp_sender.h
@@ -100,12 +100,6 @@ class RTCPSender final {
 
   int32_t SetCNAME(const char* cName) RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
 
-  int32_t AddMixedCNAME(uint32_t SSRC, const char* c_name)
-      RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
-
-  int32_t RemoveMixedCNAME(uint32_t SSRC)
-      RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
-
   bool TimeToSendRTCPReport(bool sendKeyframeBeforeRTP = false) const
       RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
 
@@ -129,8 +123,6 @@ class RTCPSender final {
 
   bool TMMBR() const RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
 
-  void SetTMMBRStatus(bool enable) RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
-
   void SetMaxRtpPacketSize(size_t max_packet_size)
       RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
 
@@ -219,8 +211,6 @@ class RTCPSender final {
 
   ReceiveStatisticsProvider* receive_statistics_
       RTC_GUARDED_BY(mutex_rtcp_sender_);
-  std::map<uint32_t, std::string> csrc_cnames_
-      RTC_GUARDED_BY(mutex_rtcp_sender_);
 
   // send CSRCs
   std::vector<uint32_t> csrcs_ RTC_GUARDED_BY(mutex_rtcp_sender_);
diff --git a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
index 6bf75c6be1..2c0bb2e2c4 100644
--- a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
@@ -294,20 +294,6 @@ TEST_F(RtcpSenderTest, SendSdes) {
   EXPECT_EQ("alice@host", parser()->sdes()->chunks()[0].cname);
 }
 
-TEST_F(RtcpSenderTest, SendSdesWithMaxChunks) {
-  auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
-  rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
-  EXPECT_EQ(0, rtcp_sender->SetCNAME("alice@host"));
-  const char cname[] = "smith@host";
-  for (size_t i = 0; i < 30; ++i) {
-    const uint32_t csrc = 0x1234 + i;
-    EXPECT_EQ(0, rtcp_sender->AddMixedCNAME(csrc, cname));
-  }
-  EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpSdes));
-  EXPECT_EQ(1, parser()->sdes()->num_packets());
-  EXPECT_EQ(31U, parser()->sdes()->chunks().size());
-}
-
 TEST_F(RtcpSenderTest, SdesIncludedInCompoundPacket) {
   auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
   rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
@@ -588,25 +574,6 @@ TEST_F(RtcpSenderTest, SendTmmbr) {
   // TODO(asapersson): tmmbr_item()->Overhead() looks broken, always zero.
 }
 
-TEST_F(RtcpSenderTest, TmmbrIncludedInCompoundPacketIfEnabled) {
-  const unsigned int kBitrateBps = 312000;
-  auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
-  rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
-  EXPECT_FALSE(rtcp_sender->TMMBR());
-  rtcp_sender->SetTMMBRStatus(true);
-  EXPECT_TRUE(rtcp_sender->TMMBR());
-  rtcp_sender->SetTargetBitrate(kBitrateBps);
-  EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
-  EXPECT_EQ(1, parser()->tmmbr()->num_packets());
-  EXPECT_EQ(1U, parser()->tmmbr()->requests().size());
-  // TMMBR should be included in each compound packet.
-  EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
-  EXPECT_EQ(2, parser()->tmmbr()->num_packets());
-
-  rtcp_sender->SetTMMBRStatus(false);
-  EXPECT_FALSE(rtcp_sender->TMMBR());
-}
-
 TEST_F(RtcpSenderTest, SendTmmbn) {
   auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
   rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
diff --git a/modules/rtp_rtcp/source/rtp_sender.cc b/modules/rtp_rtcp/source/rtp_sender.cc
index 13ec11195d..d9796ceb74 100644
--- a/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/modules/rtp_rtcp/source/rtp_sender.cc
@@ -228,15 +228,6 @@ void RTPSender::SetExtmapAllowMixed(bool extmap_allow_mixed) {
   rtp_header_extension_map_.SetExtmapAllowMixed(extmap_allow_mixed);
 }
 
-int32_t RTPSender::RegisterRtpHeaderExtension(RTPExtensionType type,
-                                              uint8_t id) {
-  MutexLock lock(&send_mutex_);
-  bool registered = rtp_header_extension_map_.RegisterByType(id, type);
-  supports_bwe_extension_ = HasBweExtension(rtp_header_extension_map_);
-  UpdateHeaderSizes();
-  return registered ? 0 : -1;
-}
-
 bool RTPSender::RegisterRtpHeaderExtension(absl::string_view uri, int id) {
   MutexLock lock(&send_mutex_);
   bool registered = rtp_header_extension_map_.RegisterByUri(id, uri);
diff --git a/modules/rtp_rtcp/source/rtp_sender.h b/modules/rtp_rtcp/source/rtp_sender.h
index 1580259b36..f2b493d0c2 100644
--- a/modules/rtp_rtcp/source/rtp_sender.h
+++ b/modules/rtp_rtcp/source/rtp_sender.h
@@ -78,8 +78,6 @@ class RTPSender {
       RTC_LOCKS_EXCLUDED(send_mutex_);
 
   // RTP header extension
-  int32_t RegisterRtpHeaderExtension(RTPExtensionType type, uint8_t id)
-      RTC_LOCKS_EXCLUDED(send_mutex_);
   bool RegisterRtpHeaderExtension(absl::string_view uri, int id)
       RTC_LOCKS_EXCLUDED(send_mutex_);
   bool IsRtpHeaderExtensionRegistered(RTPExtensionType type) const
diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index 69bdbb491e..cb4350d70d 100644
--- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -451,16 +451,16 @@ class RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
   // Enable sending of the MID header extension for both the primary SSRC and
   // the RTX SSRC.
   void EnableMidSending(const std::string& mid) {
-    rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionMid, kMidExtensionId);
+    rtp_sender()->RegisterRtpHeaderExtension(RtpMid::kUri, kMidExtensionId);
     rtp_sender()->SetMid(mid);
   }
 
   // Enable sending of the RSID header extension for the primary SSRC and the
   // RRSID header extension for the RTX SSRC.
   void EnableRidSending(const std::string& rid) {
-    rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionRtpStreamId,
+    rtp_sender()->RegisterRtpHeaderExtension(RtpStreamId::kUri,
                                              kRidExtensionId);
-    rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionRepairedRtpStreamId,
+    rtp_sender()->RegisterRtpHeaderExtension(RepairedRtpStreamId::kUri,
                                              kRepairedRidExtensionId);
     rtp_sender()->SetRid(rid);
   }
@@ -488,19 +488,16 @@ TEST_P(RtpSenderTestWithoutPacer, AllocatePacketSetCsrc) {
 
 TEST_P(RtpSenderTestWithoutPacer, AllocatePacketReserveExtensions) {
   // Configure rtp_sender with extensions.
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransmissionTimeOffset,
-                   kTransmissionTimeOffsetExtensionId));
-  ASSERT_EQ(0,
-            rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionAudioLevel, kAudioLevelExtensionId));
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransportSequenceNumber,
-                   kTransportSequenceNumberExtensionId));
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionVideoRotation, kVideoRotationExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(AudioLevel::kUri,
+                                                       kAudioLevelExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      VideoOrientation::kUri, kVideoRotationExtensionId));
 
   auto packet = rtp_sender()->AllocatePacket();
 
@@ -615,9 +612,8 @@ TEST_P(RtpSenderTestWithoutPacer,
   rtp_sender_context_ =
       std::make_unique<RtpSenderContext>(config, &time_controller_);
 
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransportSequenceNumber,
-                   kTransportSequenceNumberExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
 
   const size_t expected_bytes = GetParam().with_overhead
                                     ? kPayloadSize + kRtpOverheadBytesPerPacket
@@ -650,9 +646,8 @@ TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
   rtp_sender_context_ =
       std::make_unique<RtpSenderContext>(config, &time_controller_);
 
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransportSequenceNumber,
-                   kTransportSequenceNumberExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
 
   EXPECT_CALL(send_packet_observer_,
               OnSendPacket(kTransportSequenceNumber, _, _))
@@ -698,7 +693,7 @@ TEST_P(RtpSenderTestWithoutPacer, PacketOptionsNoRetransmission) {
 TEST_P(RtpSenderTestWithoutPacer,
        SetsIncludedInFeedbackWhenTransportSequenceNumberExtensionIsRegistered) {
   SetUpRtpSender(false, false, false);
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
+  rtp_sender()->RegisterRtpHeaderExtension(TransportSequenceNumber::kUri,
                                            kTransportSequenceNumberExtensionId);
   EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1);
   SendGenericPacket();
@@ -709,7 +704,7 @@ TEST_P(
     RtpSenderTestWithoutPacer,
     SetsIncludedInAllocationWhenTransportSequenceNumberExtensionIsRegistered) {
   SetUpRtpSender(false, false, false);
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
+  rtp_sender()->RegisterRtpHeaderExtension(TransportSequenceNumber::kUri,
                                            kTransportSequenceNumberExtensionId);
   EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1);
   SendGenericPacket();
@@ -812,9 +807,8 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) {
 }
 
 TEST_P(RtpSenderTestWithoutPacer, OnSendPacketUpdated) {
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransportSequenceNumber,
-                   kTransportSequenceNumberExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
   EXPECT_CALL(send_packet_observer_,
               OnSendPacket(kTransportSequenceNumber, _, _))
       .Times(1);
@@ -838,9 +832,8 @@ TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
   rtp_sender()->SetSequenceNumber(kSeqNum);
   rtp_sender_context_->packet_history_.SetStorePacketsStatus(
       RtpPacketHistory::StorageMode::kStoreAndCull, 10);
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransportSequenceNumber,
-                   kTransportSequenceNumberExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
 
   EXPECT_CALL(send_packet_observer_,
               OnSendPacket(kTransportSequenceNumber, _, _))
@@ -877,8 +870,8 @@ TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
 TEST_P(RtpSenderTest, WritesPacerExitToTimingExtension) {
   rtp_sender_context_->packet_history_.SetStorePacketsStatus(
       RtpPacketHistory::StorageMode::kStoreAndCull, 10);
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionVideoTiming, kVideoTimingExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      VideoTimingExtension::kUri, kVideoTimingExtensionId));
   int64_t capture_time_ms = clock_->TimeInMilliseconds();
   auto packet = rtp_sender()->AllocatePacket();
   packet->SetPayloadType(kPayload);
@@ -912,8 +905,8 @@ TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithPacer) {
   SetUpRtpSender(/*pacer=*/true, /*populate_network2=*/true, false);
   rtp_sender_context_->packet_history_.SetStorePacketsStatus(
       RtpPacketHistory::StorageMode::kStoreAndCull, 10);
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionVideoTiming, kVideoTimingExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      VideoTimingExtension::kUri, kVideoTimingExtensionId));
   int64_t capture_time_ms = clock_->TimeInMilliseconds();
   auto packet = rtp_sender()->AllocatePacket();
   packet->SetPayloadType(kPayload);
@@ -949,8 +942,8 @@ TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithPacer) {
 
 TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithoutPacer) {
   SetUpRtpSender(/*pacer=*/false, /*populate_network2=*/true, false);
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionVideoTiming, kVideoTimingExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      VideoTimingExtension::kUri, kVideoTimingExtensionId));
   auto packet = rtp_sender()->AllocatePacket();
   packet->SetMarker(true);
   packet->set_capture_time_ms(clock_->TimeInMilliseconds());
@@ -978,12 +971,10 @@ TEST_P(RtpSenderTest, TrafficSmoothingWithExtensions) {
 
   rtp_sender_context_->packet_history_.SetStorePacketsStatus(
       RtpPacketHistory::StorageMode::kStoreAndCull, 10);
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransmissionTimeOffset,
-                   kTransmissionTimeOffsetExtensionId));
-  EXPECT_EQ(0,
-            rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
   int64_t capture_time_ms = clock_->TimeInMilliseconds();
   auto packet =
       BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms);
@@ -1023,12 +1014,10 @@ TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) {
 
   rtp_sender_context_->packet_history_.SetStorePacketsStatus(
       RtpPacketHistory::StorageMode::kStoreAndCull, 10);
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransmissionTimeOffset,
-                   kTransmissionTimeOffsetExtensionId));
-  EXPECT_EQ(0,
-            rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
   int64_t capture_time_ms = clock_->TimeInMilliseconds();
   auto packet =
       BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms);
@@ -1094,13 +1083,11 @@ TEST_P(RtpSenderTest, SendPadding) {
   rtp_sender_context_->packet_history_.SetStorePacketsStatus(
       RtpPacketHistory::StorageMode::kStoreAndCull, 10);
   size_t rtp_header_len = kRtpHeaderSize;
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransmissionTimeOffset,
-                   kTransmissionTimeOffsetExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
   rtp_header_len += 4;  // 4 bytes extension.
-  EXPECT_EQ(0,
-            rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
   rtp_header_len += 4;  // 4 bytes extension.
   rtp_header_len += 4;  // 4 extra bytes common to all extension headers.
 
@@ -1196,9 +1183,8 @@ TEST_P(RtpSenderTest, SendPadding) {
 }
 
 TEST_P(RtpSenderTest, OnSendPacketUpdated) {
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransportSequenceNumber,
-                   kTransportSequenceNumberExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
   rtp_sender_context_->packet_history_.SetStorePacketsStatus(
       RtpPacketHistory::StorageMode::kStoreAndCull, 10);
 
@@ -1220,9 +1206,8 @@ TEST_P(RtpSenderTest, OnSendPacketUpdated) {
 }
 
 TEST_P(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransportSequenceNumber,
-                   kTransportSequenceNumberExtensionId));
+  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
   rtp_sender_context_->packet_history_.SetStorePacketsStatus(
       RtpPacketHistory::StorageMode::kStoreAndCull, 10);
 
@@ -2073,7 +2058,7 @@ TEST_P(RtpSenderTest, OnOverheadChanged) {
   // Base RTP overhead is 12B.
   EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u);
 
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
+  rtp_sender()->RegisterRtpHeaderExtension(TransmissionOffset::kUri,
                                            kTransmissionTimeOffsetExtensionId);
 
   // TransmissionTimeOffset extension has a size of 3B, but with the addition
@@ -2093,9 +2078,8 @@ TEST_P(RtpSenderTest, CountMidOnlyUntilAcked) {
   // Base RTP overhead is 12B.
   EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u);
 
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionMid, kMidExtensionId);
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionRtpStreamId,
-                                           kRidExtensionId);
+  rtp_sender()->RegisterRtpHeaderExtension(RtpMid::kUri, kMidExtensionId);
+  rtp_sender()->RegisterRtpHeaderExtension(RtpStreamId::kUri, kRidExtensionId);
 
   // Counted only if set.
   EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u);
@@ -2121,14 +2105,16 @@ TEST_P(RtpSenderTest, DontCountVolatileExtensionsIntoOverhead) {
   // Base RTP overhead is 12B.
   EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u);
 
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionInbandComfortNoise, 1);
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteCaptureTime, 2);
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionVideoRotation, 3);
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionPlayoutDelay, 4);
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionVideoContentType, 5);
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionVideoTiming, 6);
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionRepairedRtpStreamId, 7);
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionColorSpace, 8);
+  rtp_sender()->RegisterRtpHeaderExtension(InbandComfortNoiseExtension::kUri,
+                                           1);
+  rtp_sender()->RegisterRtpHeaderExtension(AbsoluteCaptureTimeExtension::kUri,
+                                           2);
+  rtp_sender()->RegisterRtpHeaderExtension(VideoOrientation::kUri, 3);
+  rtp_sender()->RegisterRtpHeaderExtension(PlayoutDelayLimits::kUri, 4);
+  rtp_sender()->RegisterRtpHeaderExtension(VideoContentTypeExtension::kUri, 5);
+  rtp_sender()->RegisterRtpHeaderExtension(VideoTimingExtension::kUri, 6);
+  rtp_sender()->RegisterRtpHeaderExtension(RepairedRtpStreamId::kUri, 7);
+  rtp_sender()->RegisterRtpHeaderExtension(ColorSpaceExtension::kUri, 8);
 
   // Still only 12B counted since can't count on above being sent.
   EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u);
@@ -2268,16 +2254,12 @@ TEST_P(RtpSenderTest, SendPacketHandlesRetransmissionHistory) {
 }
 
 TEST_P(RtpSenderTest, SendPacketUpdatesExtensions) {
-  ASSERT_EQ(rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionTransmissionTimeOffset,
-                kTransmissionTimeOffsetExtensionId),
-            0);
-  ASSERT_EQ(rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId),
-            0);
-  ASSERT_EQ(rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionVideoTiming,
-                                                     kVideoTimingExtensionId),
-            0);
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      VideoTimingExtension::kUri, kVideoTimingExtensionId));
 
   std::unique_ptr<RtpPacketToSend> packet =
       BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
@@ -2303,10 +2285,8 @@ TEST_P(RtpSenderTest, SendPacketUpdatesExtensions) {
 
 TEST_P(RtpSenderTest, SendPacketSetsPacketOptions) {
   const uint16_t kPacketId = 42;
-  ASSERT_EQ(rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionTransportSequenceNumber,
-                kTransportSequenceNumberExtensionId),
-            0);
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
   std::unique_ptr<RtpPacketToSend> packet =
       BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
   packet->SetExtension<TransportSequenceNumber>(kPacketId);
@@ -2344,9 +2324,8 @@ TEST_P(RtpSenderTest, SendPacketUpdatesStats) {
   config.send_packet_observer = &send_packet_observer_;
   rtp_sender_context_ =
       std::make_unique<RtpSenderContext>(config, &time_controller_);
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransportSequenceNumber,
-                   kTransportSequenceNumberExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
 
   const int64_t capture_time_ms = clock_->TimeInMilliseconds();
 
@@ -2408,15 +2387,12 @@ TEST_P(RtpSenderTest, GeneratedPaddingHasBweExtensions) {
   rtp_sender_context_->packet_history_.SetStorePacketsStatus(
       RtpPacketHistory::StorageMode::kStoreAndCull, 1);
 
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransmissionTimeOffset,
-                   kTransmissionTimeOffsetExtensionId));
-  ASSERT_EQ(0,
-            rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransportSequenceNumber,
-                   kTransportSequenceNumberExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
 
   // Send a payload packet first, to enable padding and populate the packet
   // history.
@@ -2482,9 +2458,8 @@ TEST_P(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
   rtp_sender_context_->packet_history_.SetStorePacketsStatus(
       RtpPacketHistory::StorageMode::kStoreAndCull, 1);
 
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransportSequenceNumber,
-                   kTransportSequenceNumberExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
 
   const size_t kPayloadPacketSize = kMinPaddingSize;
   std::unique_ptr<RtpPacketToSend> packet =
@@ -2536,9 +2511,8 @@ TEST_P(RtpSenderTest, LimitsPayloadPaddingSize) {
   rtp_sender_context_->packet_history_.SetStorePacketsStatus(
       RtpPacketHistory::StorageMode::kStoreAndCull, 1);
 
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransportSequenceNumber,
-                   kTransportSequenceNumberExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
 
   // Send a dummy video packet so it ends up in the packet history.
   const size_t kPayloadPacketSize = 1234u;
@@ -2573,15 +2547,12 @@ TEST_P(RtpSenderTest, LimitsPayloadPaddingSize) {
 TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) {
   rtp_sender_context_->packet_history_.SetStorePacketsStatus(
       RtpPacketHistory::StorageMode::kStoreAndCull, 1);
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransmissionTimeOffset,
-                   kTransmissionTimeOffsetExtensionId));
-  ASSERT_EQ(0,
-            rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransportSequenceNumber,
-                   kTransportSequenceNumberExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
+  ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
+      TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
 
   const size_t kPayloadPacketSize = 1234;
   // Send a dummy video packet so it ends up in the packet history. Since we
@@ -2632,10 +2603,9 @@ TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) {
 TEST_P(RtpSenderTest, SupportsPadding) {
   bool kSendingMediaStats[] = {true, false};
   bool kEnableRedundantPayloads[] = {true, false};
-  RTPExtensionType kBweExtensionTypes[] = {
-      kRtpExtensionTransportSequenceNumber,
-      kRtpExtensionTransportSequenceNumber02, kRtpExtensionAbsoluteSendTime,
-      kRtpExtensionTransmissionTimeOffset};
+  absl::string_view kBweExtensionUris[] = {
+      TransportSequenceNumber::kUri, TransportSequenceNumberV2::kUri,
+      AbsoluteSendTime::kUri, TransmissionOffset::kUri};
   const int kExtensionsId = 7;
 
   for (bool sending_media : kSendingMediaStats) {
@@ -2647,9 +2617,9 @@ TEST_P(RtpSenderTest, SupportsPadding) {
       }
       rtp_sender()->SetRtxStatus(rtx_mode);
 
-      for (auto extension_type : kBweExtensionTypes) {
+      for (auto extension_uri : kBweExtensionUris) {
         EXPECT_FALSE(rtp_sender()->SupportsPadding());
-        rtp_sender()->RegisterRtpHeaderExtension(extension_type, kExtensionsId);
+        rtp_sender()->RegisterRtpHeaderExtension(extension_uri, kExtensionsId);
         if (!sending_media) {
           EXPECT_FALSE(rtp_sender()->SupportsPadding());
         } else {
@@ -2660,7 +2630,7 @@ TEST_P(RtpSenderTest, SupportsPadding) {
             EXPECT_FALSE(rtp_sender()->SupportsRtxPayloadPadding());
           }
         }
-        rtp_sender()->DeregisterRtpHeaderExtension(extension_type);
+        rtp_sender()->DeregisterRtpHeaderExtension(extension_uri);
         EXPECT_FALSE(rtp_sender()->SupportsPadding());
       }
     }
@@ -2668,7 +2638,7 @@ TEST_P(RtpSenderTest, SupportsPadding) {
 }
 
 TEST_P(RtpSenderTest, SetsCaptureTimeAndPopulatesTransmissionOffset) {
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
+  rtp_sender()->RegisterRtpHeaderExtension(TransmissionOffset::kUri,
                                            kTransmissionTimeOffsetExtensionId);
 
   rtp_sender()->SetSendingMediaStatus(true);