diff --git a/modules/rtp_rtcp/source/rtp_sender_video.cc b/modules/rtp_rtcp/source/rtp_sender_video.cc
index b6799c9..e6fca7c 100644
--- a/modules/rtp_rtcp/source/rtp_sender_video.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_video.cc
@@ -255,28 +255,6 @@
 
 RTPSenderVideo::~RTPSenderVideo() {}
 
-void RTPSenderVideo::RegisterPayloadType(int8_t payload_type,
-                                         absl::string_view payload_name,
-                                         bool raw_payload) {
-  absl::optional<VideoCodecType> video_type;
-  if (!raw_payload) {
-    if (absl::EqualsIgnoreCase(payload_name, "VP8")) {
-      video_type = kVideoCodecVP8;
-    } else if (absl::EqualsIgnoreCase(payload_name, "VP9")) {
-      video_type = kVideoCodecVP9;
-    } else if (absl::EqualsIgnoreCase(payload_name, "H264")) {
-      video_type = kVideoCodecH264;
-    } else {
-      video_type = kVideoCodecGeneric;
-    }
-  }
-
-  {
-    rtc::CritScope cs(&payload_type_crit_);
-    payload_type_map_[payload_type] = video_type;
-  }
-}
-
 void RTPSenderVideo::AppendAsRedMaybeWithUlpfec(
     std::unique_ptr<RtpPacketToSend> media_packet,
     bool protect_media_packet,
@@ -284,44 +262,39 @@
   std::unique_ptr<RtpPacketToSend> red_packet(
       new RtpPacketToSend(*media_packet));
   BuildRedPayload(*media_packet, red_packet.get());
+  red_packet->SetPayloadType(*red_payload_type_);
 
   std::vector<std::unique_ptr<RedPacket>> fec_packets;
-  {
-    // Only protect while creating RED and FEC packets, not when sending.
-    rtc::CritScope cs(&crit_);
-    red_packet->SetPayloadType(*red_payload_type_);
-    if (ulpfec_enabled()) {
-      if (protect_media_packet) {
-        if (exclude_transport_sequence_number_from_fec_experiment_) {
-          // See comments at the top of the file why experiment
-          // "WebRTC-kExcludeTransportSequenceNumberFromFec" is needed in
-          // conjunction with datagram transport.
-          // TODO(sukhanov): We may also need to implement it for flexfec_sender
-          // if we decide to keep this approach in the future.
-          uint16_t transport_senquence_number;
-          if (media_packet->GetExtension<webrtc::TransportSequenceNumber>(
-                  &transport_senquence_number)) {
-            if (!media_packet->RemoveExtension(
-                    webrtc::TransportSequenceNumber::kId)) {
-              RTC_NOTREACHED()
-                  << "Failed to remove transport sequence number, packet="
-                  << media_packet->ToString();
-            }
+  if (ulpfec_enabled()) {
+    if (protect_media_packet) {
+      if (exclude_transport_sequence_number_from_fec_experiment_) {
+        // See comments at the top of the file why experiment
+        // "WebRTC-kExcludeTransportSequenceNumberFromFec" is needed in
+        // conjunction with datagram transport.
+        // TODO(sukhanov): We may also need to implement it for flexfec_sender
+        // if we decide to keep this approach in the future.
+        uint16_t transport_senquence_number;
+        if (media_packet->GetExtension<webrtc::TransportSequenceNumber>(
+                &transport_senquence_number)) {
+          if (!media_packet->RemoveExtension(
+                  webrtc::TransportSequenceNumber::kId)) {
+            RTC_NOTREACHED()
+                << "Failed to remove transport sequence number, packet="
+                << media_packet->ToString();
           }
         }
+      }
 
-        ulpfec_generator_.AddRtpPacketAndGenerateFec(
-            media_packet->Buffer(), media_packet->headers_size());
-      }
-      uint16_t num_fec_packets = ulpfec_generator_.NumAvailableFecPackets();
-      if (num_fec_packets > 0) {
-        uint16_t first_fec_sequence_number =
-            rtp_sender_->AllocateSequenceNumber(num_fec_packets);
-        fec_packets = ulpfec_generator_.GetUlpfecPacketsAsRed(
-            *red_payload_type_, *ulpfec_payload_type_,
-            first_fec_sequence_number);
-        RTC_DCHECK_EQ(num_fec_packets, fec_packets.size());
-      }
+      ulpfec_generator_.AddRtpPacketAndGenerateFec(
+          media_packet->Buffer(), media_packet->headers_size());
+    }
+    uint16_t num_fec_packets = ulpfec_generator_.NumAvailableFecPackets();
+    if (num_fec_packets > 0) {
+      uint16_t first_fec_sequence_number =
+          rtp_sender_->AllocateSequenceNumber(num_fec_packets);
+      fec_packets = ulpfec_generator_.GetUlpfecPacketsAsRed(
+          *red_payload_type_, *ulpfec_payload_type_, first_fec_sequence_number);
+      RTC_DCHECK_EQ(num_fec_packets, fec_packets.size());
     }
   }
 
@@ -405,33 +378,7 @@
   }
 }
 
-void RTPSenderVideo::SetUlpfecConfig(int red_payload_type,
-                                     int ulpfec_payload_type) {
-  // Sanity check. Per the definition of UlpfecConfig (see config.h),
-  // a payload type of -1 means that the corresponding feature is
-  // turned off.
-  RTC_DCHECK_GE(red_payload_type, -1);
-  RTC_DCHECK_LE(red_payload_type, 127);
-  RTC_DCHECK_GE(ulpfec_payload_type, -1);
-  RTC_DCHECK_LE(ulpfec_payload_type, 127);
-
-  rtc::CritScope cs(&crit_);
-  if (red_payload_type != -1) {
-    red_payload_type_ = red_payload_type;
-  }
-  if (ulpfec_payload_type != -1) {
-    ulpfec_payload_type_ = ulpfec_payload_type;
-  }
-
-  // Must not enable ULPFEC without RED.
-  RTC_DCHECK(!(red_enabled() ^ ulpfec_enabled()));
-
-  // Reset FEC parameters.
-  delta_fec_params_ = FecProtectionParams{0, 1, kFecMaskRandom};
-  key_fec_params_ = FecProtectionParams{0, 1, kFecMaskRandom};
-}
-
-size_t RTPSenderVideo::CalculateFecPacketOverhead() const {
+size_t RTPSenderVideo::FecPacketOverhead() const {
   if (flexfec_enabled())
     return flexfec_sender_->MaxPacketOverhead();
 
@@ -468,54 +415,6 @@
 }
 
 bool RTPSenderVideo::SendVideo(
-    VideoFrameType frame_type,
-    int8_t payload_type,
-    uint32_t rtp_timestamp,
-    int64_t capture_time_ms,
-    const uint8_t* payload_data,
-    size_t payload_size,
-    const RTPFragmentationHeader* fragmentation,
-    const RTPVideoHeader* video_header,
-    absl::optional<int64_t> expected_retransmission_time_ms) {
-  absl::optional<VideoCodecType> codec_type;
-  {
-    rtc::CritScope cs(&payload_type_crit_);
-    const auto it = payload_type_map_.find(payload_type);
-    if (it == payload_type_map_.end()) {
-      RTC_LOG(LS_ERROR) << "Payload type " << static_cast<int>(payload_type)
-                        << " not registered.";
-      return false;
-    }
-    codec_type = it->second;
-  }
-  RTPVideoHeader rtp_video_header = *video_header;
-  rtp_video_header.frame_type = frame_type;
-  return SendVideo(payload_type, codec_type, rtp_timestamp, capture_time_ms,
-                   rtc::MakeArrayView(payload_data, payload_size),
-                   fragmentation, rtp_video_header,
-                   expected_retransmission_time_ms);
-}
-
-bool RTPSenderVideo::SendVideo(
-    VideoFrameType frame_type,
-    int8_t payload_type,
-    absl::optional<VideoCodecType> codec_type,
-    uint32_t rtp_timestamp,
-    int64_t capture_time_ms,
-    const uint8_t* payload_data,
-    size_t payload_size,
-    const RTPFragmentationHeader* fragmentation,
-    const RTPVideoHeader* video_header,
-    absl::optional<int64_t> expected_retransmission_time_ms) {
-  RTPVideoHeader rtp_video_header = *video_header;
-  rtp_video_header.frame_type = frame_type;
-  return SendVideo(payload_type, codec_type, rtp_timestamp, capture_time_ms,
-                   rtc::MakeArrayView(payload_data, payload_size),
-                   fragmentation, rtp_video_header,
-                   expected_retransmission_time_ms);
-}
-
-bool RTPSenderVideo::SendVideo(
     int payload_type,
     absl::optional<VideoCodecType> codec_type,
     uint32_t rtp_timestamp,
@@ -581,9 +480,7 @@
         transmit_color_space_next_frame_ ? !IsBaseLayer(video_header) : false;
   }
 
-  size_t fec_packet_overhead;
-  bool red_enabled;
-  {
+  if (flexfec_enabled() || ulpfec_enabled()) {
     rtc::CritScope cs(&crit_);
     // FEC settings.
     const FecProtectionParams& fec_params =
@@ -594,14 +491,11 @@
       flexfec_sender_->SetFecParameters(fec_params);
     if (ulpfec_enabled())
       ulpfec_generator_.SetFecParameters(fec_params);
-
-    fec_packet_overhead = CalculateFecPacketOverhead();
-    red_enabled = this->red_enabled();
   }
 
   // Maximum size of packet including rtp headers.
   // Extra space left in case packet will be resent using fec or rtx.
-  int packet_capacity = rtp_sender_->MaxRtpPacketSize() - fec_packet_overhead -
+  int packet_capacity = rtp_sender_->MaxRtpPacketSize() - FecPacketOverhead() -
                         (rtp_sender_->RtxStatus() ? kRtxHeaderSize : 0);
 
   std::unique_ptr<RtpPacketToSend> single_packet =
@@ -782,7 +676,7 @@
       protect_packet = false;
     }
 
-    if (red_enabled) {
+    if (red_enabled()) {
       AppendAsRedMaybeWithUlpfec(std::move(packet), protect_packet,
                                  &rtp_packets);
     } else {
diff --git a/modules/rtp_rtcp/source/rtp_sender_video.h b/modules/rtp_rtcp/source/rtp_sender_video.h
index 8906e31..9cc7e4f 100644
--- a/modules/rtp_rtcp/source/rtp_sender_video.h
+++ b/modules/rtp_rtcp/source/rtp_sender_video.h
@@ -102,43 +102,6 @@
                  const RTPFragmentationHeader* fragmentation,
                  RTPVideoHeader video_header,
                  absl::optional<int64_t> expected_retransmission_time_ms);
-
-  RTC_DEPRECATED
-  bool SendVideo(VideoFrameType frame_type,
-                 int8_t payload_type,
-                 absl::optional<VideoCodecType> codec_type,
-                 uint32_t rtp_timestamp,
-                 int64_t capture_time_ms,
-                 const uint8_t* payload_data,
-                 size_t payload_size,
-                 const RTPFragmentationHeader* fragmentation,
-                 const RTPVideoHeader* video_header,
-                 absl::optional<int64_t> expected_retransmission_time_ms);
-
-  // TODO(bugs.webrtc.org/10809): Remove when downstream usage is gone.
-  RTC_DEPRECATED
-  bool SendVideo(VideoFrameType frame_type,
-                 int8_t payload_type,
-                 uint32_t capture_timestamp,
-                 int64_t capture_time_ms,
-                 const uint8_t* payload_data,
-                 size_t payload_size,
-                 const RTPFragmentationHeader* fragmentation,
-                 const RTPVideoHeader* video_header,
-                 absl::optional<int64_t> expected_retransmission_time_ms);
-
-  // TODO(bugs.webrtc.org/10809): Remove when downstream usage is gone.
-  void RegisterPayloadType(int8_t payload_type,
-                           absl::string_view payload_name,
-                           bool raw_payload);
-
-  // Set RED and ULPFEC payload types. A payload type of -1 means that the
-  // corresponding feature is turned off. Note that we DO NOT support enabling
-  // ULPFEC without enabling RED, and RED is only ever used when ULPFEC is
-  // enabled.
-  // TODO(bugs.webrtc.org/10809): Remove when downstream usage is gone.
-  void SetUlpfecConfig(int red_payload_type, int ulpfec_payload_type);
-
   // FlexFEC/ULPFEC.
   // Set FEC rates, max frames before FEC is sent, and type of FEC masks.
   // Returns false on failure.
@@ -182,12 +145,13 @@
     int64_t last_frame_time_ms;
   };
 
-  size_t CalculateFecPacketOverhead() const RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  size_t FecPacketOverhead() const RTC_EXCLUSIVE_LOCKS_REQUIRED(send_checker_);
 
   void AppendAsRedMaybeWithUlpfec(
       std::unique_ptr<RtpPacketToSend> media_packet,
       bool protect_media_packet,
-      std::vector<std::unique_ptr<RtpPacketToSend>>* packets);
+      std::vector<std::unique_ptr<RtpPacketToSend>>* packets)
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(send_checker_);
 
   // TODO(brandtr): Remove the FlexFEC functions when FlexfecSender has been
   // moved to PacedSender.
@@ -198,13 +162,9 @@
       std::vector<std::unique_ptr<RtpPacketToSend>> packets,
       size_t unpacketized_payload_size);
 
-  bool red_enabled() const RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_) {
-    return red_payload_type_.has_value();
-  }
+  bool red_enabled() const { return red_payload_type_.has_value(); }
 
-  bool ulpfec_enabled() const RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_) {
-    return ulpfec_payload_type_.has_value();
-  }
+  bool ulpfec_enabled() const { return ulpfec_payload_type_.has_value(); }
 
   bool flexfec_enabled() const { return flexfec_sender_ != nullptr; }
 
@@ -215,12 +175,6 @@
   RTPSender* const rtp_sender_;
   Clock* const clock_;
 
-  // Maps payload type to codec type, for packetization.
-  // TODO(bugs.webrtc.org/10809): Remove when downstream usage is gone.
-  rtc::CriticalSection payload_type_crit_;
-  std::map<int8_t, absl::optional<VideoCodecType>> payload_type_map_
-      RTC_GUARDED_BY(payload_type_crit_);
-
   const int32_t retransmission_settings_;
 
   // These members should only be accessed from within SendVideo() to avoid
@@ -246,9 +200,9 @@
       RTC_PT_GUARDED_BY(crit_);
 
   // RED/ULPFEC.
-  absl::optional<int> red_payload_type_ RTC_GUARDED_BY(crit_);
-  absl::optional<int> ulpfec_payload_type_ RTC_GUARDED_BY(crit_);
-  UlpfecGenerator ulpfec_generator_ RTC_GUARDED_BY(crit_);
+  const absl::optional<int> red_payload_type_;
+  const absl::optional<int> ulpfec_payload_type_;
+  UlpfecGenerator ulpfec_generator_ RTC_GUARDED_BY(send_checker_);
 
   // FlexFEC.
   FlexfecSender* const flexfec_sender_;