diff --git a/media/BUILD.gn b/media/BUILD.gn
index b884b0d049..07a5f2dfab 100644
--- a/media/BUILD.gn
+++ b/media/BUILD.gn
@@ -52,6 +52,7 @@ rtc_library("rtc_media_base") {
     ":rtc_media_config",
     "../api:array_view",
     "../api:audio_options_api",
+    "../api:call_api",
     "../api:field_trials_view",
     "../api:frame_transformer_interface",
     "../api:media_stream_interface",
@@ -72,6 +73,7 @@ rtc_library("rtc_media_base") {
     "../api/transport:stun_types",
     "../api/transport/rtp:rtp_source",
     "../api/units:time_delta",
+    "../api/video:recordable_encoded_frame",
     "../api/video:video_bitrate_allocation",
     "../api/video:video_bitrate_allocator_factory",
     "../api/video:video_frame",
diff --git a/media/base/media_channel.h b/media/base/media_channel.h
index 77a5ba6d5c..ee9a4724b0 100644
--- a/media/base/media_channel.h
+++ b/media/base/media_channel.h
@@ -20,6 +20,7 @@
 #include "absl/types/optional.h"
 #include "api/audio_codecs/audio_encoder.h"
 #include "api/audio_options.h"
+#include "api/call/audio_sink.h"
 #include "api/crypto/frame_decryptor_interface.h"
 #include "api/crypto/frame_encryptor_interface.h"
 #include "api/frame_transformer_interface.h"
@@ -61,7 +62,6 @@ class Timing;
 }
 
 namespace webrtc {
-class AudioSinkInterface;
 class VideoFrame;
 
 webrtc::RTCError InvokeSetParametersCallback(SetParametersCallback& callback,
@@ -219,14 +219,9 @@ class MediaSendChannelInterface
  public:
   virtual ~MediaSendChannelInterface() = default;
 
-  virtual VideoMediaSendChannelInterface* AsVideoSendChannel() {
-    RTC_CHECK_NOTREACHED();
-    return nullptr;
-  }
-  virtual VoiceMediaSendChannelInterface* AsVoiceSendChannel() {
-    RTC_CHECK_NOTREACHED();
-    return nullptr;
-  }
+  virtual VideoMediaSendChannelInterface* AsVideoSendChannel() = 0;
+
+  virtual VoiceMediaSendChannelInterface* AsVoiceSendChannel() = 0;
 
   // Creates a new outgoing media stream with SSRCs and CNAME as described
   // by sp.
diff --git a/media/base/media_channel_impl.cc b/media/base/media_channel_impl.cc
index 626de3438f..eeefea0bab 100644
--- a/media/base/media_channel_impl.cc
+++ b/media/base/media_channel_impl.cc
@@ -12,6 +12,7 @@
 
 #include <map>
 #include <string>
+#include <type_traits>
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
@@ -21,6 +22,7 @@
 #include "api/rtp_sender_interface.h"
 #include "api/units/time_delta.h"
 #include "api/video/video_timing.h"
+#include "api/video_codecs/scalability_mode.h"
 #include "common_video/include/quality_limitation_reason.h"
 #include "media/base/codec.h"
 #include "media/base/media_channel.h"
diff --git a/media/base/media_channel_impl.h b/media/base/media_channel_impl.h
index 41bead70b9..45a250e03c 100644
--- a/media/base/media_channel_impl.h
+++ b/media/base/media_channel_impl.h
@@ -14,20 +14,42 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "api/audio_options.h"
+#include "api/call/audio_sink.h"
 #include "api/call/transport.h"
 #include "api/crypto/frame_decryptor_interface.h"
 #include "api/crypto/frame_encryptor_interface.h"
 #include "api/frame_transformer_interface.h"
 #include "api/media_types.h"
+#include "api/rtc_error.h"
+#include "api/rtp_parameters.h"
+#include "api/rtp_sender_interface.h"
 #include "api/scoped_refptr.h"
 #include "api/sequence_checker.h"
 #include "api/task_queue/pending_task_safety_flag.h"
 #include "api/task_queue/task_queue_base.h"
+#include "api/transport/rtp/rtp_source.h"
+#include "api/video/recordable_encoded_frame.h"
+#include "api/video/video_frame.h"
+#include "api/video/video_sink_interface.h"
+#include "api/video/video_source_interface.h"
+#include "api/video_codecs/video_encoder_factory.h"
+#include "media/base/codec.h"
 #include "media/base/media_channel.h"
+#include "media/base/stream_params.h"
 #include "rtc_base/async_packet_socket.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/copy_on_write_buffer.h"
 #include "rtc_base/dscp.h"
+#include "rtc_base/logging.h"
 #include "rtc_base/network/sent_packet.h"
 #include "rtc_base/network_route.h"
 #include "rtc_base/socket.h"
@@ -38,6 +60,8 @@
 // but this is in the process of being changed.
 // TODO(bugs.webrtc.org/13931): Consider removing these classes.
 
+// The target
+
 namespace cricket {
 
 class VoiceMediaChannel;
@@ -175,6 +199,10 @@ class VideoMediaChannel : public MediaChannel,
 
   // Downcasting to the implemented interfaces.
   VideoMediaSendChannelInterface* AsVideoSendChannel() override { return this; }
+  VoiceMediaSendChannelInterface* AsVoiceSendChannel() override {
+    RTC_CHECK_NOTREACHED();
+    return nullptr;
+  }
 
   VideoMediaReceiveChannelInterface* AsVideoReceiveChannel() override {
     return this;
@@ -225,6 +253,11 @@ class VoiceMediaChannel : public MediaChannel,
 
   VoiceMediaChannel* AsVoiceChannel() override { return this; }
 
+  VideoMediaSendChannelInterface* AsVideoSendChannel() override {
+    RTC_CHECK_NOTREACHED();
+    return nullptr;
+  }
+
   void SetExtmapAllowMixed(bool mixed) override {
     MediaChannel::SetExtmapAllowMixed(mixed);
   }
@@ -237,6 +270,374 @@ class VoiceMediaChannel : public MediaChannel,
                         bool get_and_clear_legacy_stats) = 0;
 };
 
+// The externally exposed objects that support the Send and Receive interfaces.
+// These dispatch their functions to the underlying MediaChannel objects.
+
+class VoiceMediaSendChannel : public VoiceMediaSendChannelInterface {
+ public:
+  explicit VoiceMediaSendChannel(VoiceMediaChannel* impl) : impl_(impl) {}
+  virtual ~VoiceMediaSendChannel() {}
+  VoiceMediaSendChannelInterface* AsVoiceSendChannel() override { return this; }
+  VideoMediaSendChannelInterface* AsVideoSendChannel() override {
+    RTC_CHECK_NOTREACHED();
+    return nullptr;
+  }
+
+  // Implementation of MediaBaseChannelInterface
+  cricket::MediaType media_type() const override { return MEDIA_TYPE_AUDIO; }
+  void OnPacketReceived(rtc::CopyOnWriteBuffer packet,
+                        int64_t packet_time_us) override {
+    impl()->OnPacketReceived(packet, packet_time_us);
+  }
+  void OnPacketSent(const rtc::SentPacket& sent_packet) override {
+    impl()->OnPacketSent(sent_packet);
+  }
+  void OnReadyToSend(bool ready) override { impl()->OnReadyToSend(ready); }
+  void OnNetworkRouteChanged(absl::string_view transport_name,
+                             const rtc::NetworkRoute& network_route) override {
+    impl()->OnNetworkRouteChanged(transport_name, network_route);
+  }
+  void SetExtmapAllowMixed(bool extmap_allow_mixed) override {
+    impl()->SetExtmapAllowMixed(extmap_allow_mixed);
+  }
+  bool ExtmapAllowMixed() const override { return impl()->ExtmapAllowMixed(); }
+  // Implementation of MediaSendChannelInterface
+  bool AddSendStream(const StreamParams& sp) override {
+    return impl()->AddSendStream(sp);
+  }
+  bool RemoveSendStream(uint32_t ssrc) override {
+    return impl()->RemoveSendStream(ssrc);
+  }
+  void SetFrameEncryptor(uint32_t ssrc,
+                         rtc::scoped_refptr<webrtc::FrameEncryptorInterface>
+                             frame_encryptor) override {
+    impl()->SetFrameEncryptor(ssrc, frame_encryptor);
+  }
+  webrtc::RTCError SetRtpSendParameters(
+      uint32_t ssrc,
+      const webrtc::RtpParameters& parameters,
+      webrtc::SetParametersCallback callback = nullptr) override {
+    return impl()->SetRtpSendParameters(ssrc, parameters, std::move(callback));
+  }
+
+  void SetEncoderToPacketizerFrameTransformer(
+      uint32_t ssrc,
+      rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
+      override {
+    return impl()->SetEncoderToPacketizerFrameTransformer(ssrc,
+                                                          frame_transformer);
+  }
+  void SetEncoderSelector(uint32_t ssrc,
+                          webrtc::VideoEncoderFactory::EncoderSelectorInterface*
+                              encoder_selector) override {
+    impl()->SetEncoderSelector(ssrc, encoder_selector);
+  }
+  webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const override {
+    return impl()->GetRtpSendParameters(ssrc);
+  }
+  // Implementation of VoiceMediaSendChannel
+  bool SetSendParameters(const AudioSendParameters& params) override {
+    return impl()->SetSendParameters(params);
+  }
+  void SetSend(bool send) override { return impl()->SetSend(send); }
+  bool SetAudioSend(uint32_t ssrc,
+                    bool enable,
+                    const AudioOptions* options,
+                    AudioSource* source) override {
+    return impl()->SetAudioSend(ssrc, enable, options, source);
+  }
+  bool CanInsertDtmf() override { return impl()->CanInsertDtmf(); }
+  bool InsertDtmf(uint32_t ssrc, int event, int duration) override {
+    return impl()->InsertDtmf(ssrc, event, duration);
+  }
+
+ private:
+  VoiceMediaSendChannelInterface* impl() { return impl_; }
+  const VoiceMediaSendChannelInterface* impl() const { return impl_; }
+  VoiceMediaChannel* impl_;
+};
+
+class VoiceMediaReceiveChannel : public VoiceMediaReceiveChannelInterface {
+ public:
+  explicit VoiceMediaReceiveChannel(VoiceMediaChannel* impl) : impl_(impl) {}
+  virtual ~VoiceMediaReceiveChannel() {}
+  // Implementation of MediaBaseChannelInterface
+  cricket::MediaType media_type() const override { return MEDIA_TYPE_AUDIO; }
+  void OnPacketReceived(rtc::CopyOnWriteBuffer packet,
+                        int64_t packet_time_us) override {
+    impl()->OnPacketReceived(packet, packet_time_us);
+  }
+  void OnPacketSent(const rtc::SentPacket& sent_packet) override {
+    impl()->OnPacketSent(sent_packet);
+  }
+  void OnReadyToSend(bool ready) override { impl()->OnReadyToSend(ready); }
+  void OnNetworkRouteChanged(absl::string_view transport_name,
+                             const rtc::NetworkRoute& network_route) override {
+    impl()->OnNetworkRouteChanged(transport_name, network_route);
+  }
+  void SetExtmapAllowMixed(bool extmap_allow_mixed) override {
+    impl()->SetExtmapAllowMixed(extmap_allow_mixed);
+  }
+  bool ExtmapAllowMixed() const override { return impl()->ExtmapAllowMixed(); }
+  // Implementation of Delayable
+  bool SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) override {
+    return impl()->SetBaseMinimumPlayoutDelayMs(ssrc, delay_ms);
+  }
+  absl::optional<int> GetBaseMinimumPlayoutDelayMs(
+      uint32_t ssrc) const override {
+    return impl()->GetBaseMinimumPlayoutDelayMs(ssrc);
+  }
+  // Implementation of MediaReceiveChannelInterface
+  bool AddRecvStream(const StreamParams& sp) override {
+    return impl()->AddRecvStream(sp);
+  }
+  bool RemoveRecvStream(uint32_t ssrc) override {
+    return impl()->RemoveRecvStream(ssrc);
+  }
+  void ResetUnsignaledRecvStream() override {
+    return impl()->ResetUnsignaledRecvStream();
+  }
+  void OnDemuxerCriteriaUpdatePending() override {
+    impl()->OnDemuxerCriteriaUpdatePending();
+  }
+  void OnDemuxerCriteriaUpdateComplete() override {
+    impl()->OnDemuxerCriteriaUpdateComplete();
+  }
+  void SetFrameDecryptor(uint32_t ssrc,
+                         rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
+                             frame_decryptor) override {
+    impl()->SetFrameDecryptor(ssrc, frame_decryptor);
+  }
+  void SetDepacketizerToDecoderFrameTransformer(
+      uint32_t ssrc,
+      rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
+      override {
+    impl()->SetDepacketizerToDecoderFrameTransformer(ssrc, frame_transformer);
+  }
+  // Implementation of VoiceMediaReceiveChannelInterface
+  bool SetRecvParameters(const AudioRecvParameters& params) override {
+    return impl()->SetRecvParameters(params);
+  }
+  webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override {
+    return impl()->GetRtpReceiveParameters(ssrc);
+  }
+  std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override {
+    return impl()->GetSources(ssrc);
+  }
+  webrtc::RtpParameters GetDefaultRtpReceiveParameters() const override {
+    return impl()->GetDefaultRtpReceiveParameters();
+  }
+  void SetPlayout(bool playout) override { return impl()->SetPlayout(playout); }
+  bool SetOutputVolume(uint32_t ssrc, double volume) override {
+    return impl()->SetOutputVolume(ssrc, volume);
+  }
+  bool SetDefaultOutputVolume(double volume) override {
+    return impl()->SetDefaultOutputVolume(volume);
+  }
+  void SetRawAudioSink(
+      uint32_t ssrc,
+      std::unique_ptr<webrtc::AudioSinkInterface> sink) override {
+    return impl()->SetRawAudioSink(ssrc, std::move(sink));
+  }
+  void SetDefaultRawAudioSink(
+      std::unique_ptr<webrtc::AudioSinkInterface> sink) override {
+    return impl()->SetDefaultRawAudioSink(std::move(sink));
+  }
+
+ private:
+  VoiceMediaReceiveChannelInterface* impl() { return impl_; }
+  const VoiceMediaReceiveChannelInterface* impl() const { return impl_; }
+  VoiceMediaChannel* impl_;
+};
+
+class VideoMediaSendChannel : public VideoMediaSendChannelInterface {
+ public:
+  explicit VideoMediaSendChannel(VideoMediaChannel* impl) : impl_(impl) {}
+
+  VideoMediaSendChannelInterface* AsVideoSendChannel() override { return this; }
+  VoiceMediaSendChannelInterface* AsVoiceSendChannel() override {
+    RTC_CHECK_NOTREACHED();
+    return nullptr;
+  }
+
+  // Implementation of MediaBaseChannelInterface
+  cricket::MediaType media_type() const override { return MEDIA_TYPE_AUDIO; }
+  void OnPacketReceived(rtc::CopyOnWriteBuffer packet,
+                        int64_t packet_time_us) override {
+    impl()->OnPacketReceived(packet, packet_time_us);
+  }
+  void OnPacketSent(const rtc::SentPacket& sent_packet) override {
+    impl()->OnPacketSent(sent_packet);
+  }
+  void OnReadyToSend(bool ready) override { impl()->OnReadyToSend(ready); }
+  void OnNetworkRouteChanged(absl::string_view transport_name,
+                             const rtc::NetworkRoute& network_route) override {
+    impl()->OnNetworkRouteChanged(transport_name, network_route);
+  }
+  void SetExtmapAllowMixed(bool extmap_allow_mixed) override {
+    impl()->SetExtmapAllowMixed(extmap_allow_mixed);
+  }
+  bool ExtmapAllowMixed() const override { return impl()->ExtmapAllowMixed(); }
+  // Implementation of MediaSendChannelInterface
+  bool AddSendStream(const StreamParams& sp) override {
+    return impl()->AddSendStream(sp);
+  }
+  bool RemoveSendStream(uint32_t ssrc) override {
+    return impl()->RemoveSendStream(ssrc);
+  }
+  void SetFrameEncryptor(uint32_t ssrc,
+                         rtc::scoped_refptr<webrtc::FrameEncryptorInterface>
+                             frame_encryptor) override {
+    impl()->SetFrameEncryptor(ssrc, frame_encryptor);
+  }
+  webrtc::RTCError SetRtpSendParameters(
+      uint32_t ssrc,
+      const webrtc::RtpParameters& parameters,
+      webrtc::SetParametersCallback callback = nullptr) override {
+    return impl()->SetRtpSendParameters(ssrc, parameters, std::move(callback));
+  }
+
+  void SetEncoderToPacketizerFrameTransformer(
+      uint32_t ssrc,
+      rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
+      override {
+    return impl()->SetEncoderToPacketizerFrameTransformer(ssrc,
+                                                          frame_transformer);
+  }
+  void SetEncoderSelector(uint32_t ssrc,
+                          webrtc::VideoEncoderFactory::EncoderSelectorInterface*
+                              encoder_selector) override {
+    impl()->SetEncoderSelector(ssrc, encoder_selector);
+  }
+  webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const override {
+    return impl()->GetRtpSendParameters(ssrc);
+  }
+  // Implementation of VideoMediaSendChannelInterface
+  bool SetSendParameters(const VideoSendParameters& params) override {
+    return impl()->SetSendParameters(params);
+  }
+  bool GetSendCodec(VideoCodec* send_codec) override {
+    return impl()->GetSendCodec(send_codec);
+  }
+  bool SetSend(bool send) override { return impl()->SetSend(send); }
+  bool SetVideoSend(
+      uint32_t ssrc,
+      const VideoOptions* options,
+      rtc::VideoSourceInterface<webrtc::VideoFrame>* source) override {
+    return impl()->SetVideoSend(ssrc, options, source);
+  }
+  void GenerateSendKeyFrame(uint32_t ssrc,
+                            const std::vector<std::string>& rids) override {
+    return impl()->GenerateSendKeyFrame(ssrc, rids);
+  }
+  void SetVideoCodecSwitchingEnabled(bool enabled) override {
+    return impl()->SetVideoCodecSwitchingEnabled(enabled);
+  }
+
+ private:
+  VideoMediaSendChannelInterface* impl() { return impl_; }
+  const VideoMediaSendChannelInterface* impl() const { return impl_; }
+  VideoMediaChannel* const impl_;
+};
+
+class VideoMediaReceiveChannel : public VideoMediaReceiveChannelInterface {
+ public:
+  explicit VideoMediaReceiveChannel(VideoMediaChannel* impl) : impl_(impl) {}
+  // Implementation of MediaBaseChannelInterface
+  cricket::MediaType media_type() const override { return MEDIA_TYPE_AUDIO; }
+  void OnPacketReceived(rtc::CopyOnWriteBuffer packet,
+                        int64_t packet_time_us) override {
+    impl()->OnPacketReceived(packet, packet_time_us);
+  }
+  void OnPacketSent(const rtc::SentPacket& sent_packet) override {
+    impl()->OnPacketSent(sent_packet);
+  }
+  void OnReadyToSend(bool ready) override { impl()->OnReadyToSend(ready); }
+  void OnNetworkRouteChanged(absl::string_view transport_name,
+                             const rtc::NetworkRoute& network_route) override {
+    impl()->OnNetworkRouteChanged(transport_name, network_route);
+  }
+  void SetExtmapAllowMixed(bool extmap_allow_mixed) override {
+    impl()->SetExtmapAllowMixed(extmap_allow_mixed);
+  }
+  bool ExtmapAllowMixed() const override { return impl()->ExtmapAllowMixed(); }
+  // Implementation of Delayable
+  bool SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) override {
+    return impl()->SetBaseMinimumPlayoutDelayMs(ssrc, delay_ms);
+  }
+  absl::optional<int> GetBaseMinimumPlayoutDelayMs(
+      uint32_t ssrc) const override {
+    return impl()->GetBaseMinimumPlayoutDelayMs(ssrc);
+  }
+  // Implementation of MediaReceiveChannelInterface
+  bool AddRecvStream(const StreamParams& sp) override {
+    return impl()->AddRecvStream(sp);
+  }
+  bool RemoveRecvStream(uint32_t ssrc) override {
+    return impl()->RemoveRecvStream(ssrc);
+  }
+  void ResetUnsignaledRecvStream() override {
+    return impl()->ResetUnsignaledRecvStream();
+  }
+  void OnDemuxerCriteriaUpdatePending() override {
+    impl()->OnDemuxerCriteriaUpdatePending();
+  }
+  void OnDemuxerCriteriaUpdateComplete() override {
+    impl()->OnDemuxerCriteriaUpdateComplete();
+  }
+  void SetFrameDecryptor(uint32_t ssrc,
+                         rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
+                             frame_decryptor) override {
+    impl()->SetFrameDecryptor(ssrc, frame_decryptor);
+  }
+  void SetDepacketizerToDecoderFrameTransformer(
+      uint32_t ssrc,
+      rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
+      override {
+    impl()->SetDepacketizerToDecoderFrameTransformer(ssrc, frame_transformer);
+  }
+  // Implementation on videoMediaReceiveChannelInterface
+  bool SetRecvParameters(const VideoRecvParameters& params) override {
+    return impl()->SetRecvParameters(params);
+  }
+  webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override {
+    return impl()->GetRtpReceiveParameters(ssrc);
+  }
+  webrtc::RtpParameters GetDefaultRtpReceiveParameters() const override {
+    return impl()->GetDefaultRtpReceiveParameters();
+  }
+  bool SetSink(uint32_t ssrc,
+               rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override {
+    return impl()->SetSink(ssrc, sink);
+  }
+  void SetDefaultSink(
+      rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override {
+    return impl()->SetDefaultSink(sink);
+  }
+  void RequestRecvKeyFrame(uint32_t ssrc) override {
+    return impl()->RequestRecvKeyFrame(ssrc);
+  }
+  std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override {
+    return impl()->GetSources(ssrc);
+  }
+  // Set recordable encoded frame callback for `ssrc`
+  void SetRecordableEncodedFrameCallback(
+      uint32_t ssrc,
+      std::function<void(const webrtc::RecordableEncodedFrame&)> callback)
+      override {
+    return impl()->SetRecordableEncodedFrameCallback(ssrc, std::move(callback));
+  }
+  // Clear recordable encoded frame callback for `ssrc`
+  void ClearRecordableEncodedFrameCallback(uint32_t ssrc) override {
+    impl()->ClearRecordableEncodedFrameCallback(ssrc);
+  }
+
+ private:
+  VideoMediaReceiveChannelInterface* impl() { return impl_; }
+  const VideoMediaReceiveChannelInterface* impl() const { return impl_; }
+  VideoMediaChannel* const impl_;
+};
+
 }  // namespace cricket
 
 #endif  // MEDIA_BASE_MEDIA_CHANNEL_IMPL_H_
diff --git a/pc/channel.cc b/pc/channel.cc
index 4c078def17..09ed037ee4 100644
--- a/pc/channel.cc
+++ b/pc/channel.cc
@@ -826,7 +826,9 @@ VoiceChannel::VoiceChannel(rtc::Thread* worker_thread,
                   mid,
                   srtp_required,
                   crypto_options,
-                  ssrc_generator) {}
+                  ssrc_generator),
+      send_channel_(this->media_channel()->AsVoiceChannel()),
+      receive_channel_(this->media_channel()->AsVoiceChannel()) {}
 
 VoiceChannel::~VoiceChannel() {
   TRACE_EVENT0("webrtc", "VoiceChannel::~VoiceChannel");
@@ -950,7 +952,9 @@ VideoChannel::VideoChannel(rtc::Thread* worker_thread,
                   mid,
                   srtp_required,
                   crypto_options,
-                  ssrc_generator) {}
+                  ssrc_generator),
+      send_channel_(this->media_channel()->AsVideoChannel()),
+      receive_channel_(this->media_channel()->AsVideoChannel()) {}
 
 VideoChannel::~VideoChannel() {
   TRACE_EVENT0("webrtc", "VideoChannel::~VideoChannel");
diff --git a/pc/channel.h b/pc/channel.h
index 08a66793c7..f25866ddb0 100644
--- a/pc/channel.h
+++ b/pc/channel.h
@@ -156,29 +156,21 @@ class BaseChannel : public ChannelInterface,
   // RtpPacketSinkInterface overrides.
   void OnRtpPacket(const webrtc::RtpPacketReceived& packet) override;
 
-  MediaChannel* media_channel() const override { return media_channel_.get(); }
+  MediaChannel* media_channel() override { return media_channel_.get(); }
 
-  MediaSendChannelInterface* media_send_channel() const override {
-    return media_channel_->AsSendChannel();
-  }
-  VideoMediaSendChannelInterface* video_media_send_channel() const override {
+  VideoMediaSendChannelInterface* video_media_send_channel() override {
     RTC_CHECK(false) << "Attempt to fetch video channel from non-video";
     return nullptr;
   }
-  VoiceMediaSendChannelInterface* voice_media_send_channel() const override {
+  VoiceMediaSendChannelInterface* voice_media_send_channel() override {
     RTC_CHECK(false) << "Attempt to fetch voice channel from non-voice";
     return nullptr;
   }
-  MediaReceiveChannelInterface* media_receive_channel() const override {
-    return media_channel_->AsReceiveChannel();
-  }
-  VideoMediaReceiveChannelInterface* video_media_receive_channel()
-      const override {
+  VideoMediaReceiveChannelInterface* video_media_receive_channel() override {
     RTC_CHECK(false) << "Attempt to fetch video channel from non-video";
     return nullptr;
   }
-  VoiceMediaReceiveChannelInterface* voice_media_receive_channel()
-      const override {
+  VoiceMediaReceiveChannelInterface* voice_media_receive_channel() override {
     RTC_CHECK(false) << "Attempt to fetch voice channel from non-voice";
     return nullptr;
   }
@@ -383,23 +375,20 @@ class VoiceChannel : public BaseChannel {
                rtc::UniqueRandomIdGenerator* ssrc_generator);
   ~VoiceChannel();
 
-  // downcasts a MediaChannel
-  VoiceMediaSendChannelInterface* media_send_channel() const override {
-    return media_channel()->AsVoiceChannel()->AsVoiceSendChannel();
+  VoiceMediaSendChannelInterface* media_send_channel() override {
+    return &send_channel_;
   }
 
-  VoiceMediaSendChannelInterface* voice_media_send_channel() const override {
-    return media_send_channel();
+  VoiceMediaSendChannelInterface* voice_media_send_channel() override {
+    return &send_channel_;
   }
 
-  // downcasts a MediaChannel
-  VoiceMediaReceiveChannelInterface* media_receive_channel() const override {
-    return media_channel()->AsVoiceChannel()->AsVoiceReceiveChannel();
+  VoiceMediaReceiveChannelInterface* media_receive_channel() override {
+    return &receive_channel_;
   }
 
-  VoiceMediaReceiveChannelInterface* voice_media_receive_channel()
-      const override {
-    return media_receive_channel();
+  VoiceMediaReceiveChannelInterface* voice_media_receive_channel() override {
+    return &receive_channel_;
   }
 
   cricket::MediaType media_type() const override {
@@ -418,6 +407,8 @@ class VoiceChannel : public BaseChannel {
                           std::string& error_desc)
       RTC_RUN_ON(worker_thread()) override;
 
+  VoiceMediaSendChannel send_channel_ RTC_GUARDED_BY(worker_thread());
+  VoiceMediaReceiveChannel receive_channel_ RTC_GUARDED_BY(worker_thread());
   // Last AudioSendParameters sent down to the media_channel() via
   // SetSendParameters.
   AudioSendParameters last_send_params_ RTC_GUARDED_BY(worker_thread());
@@ -440,21 +431,20 @@ class VideoChannel : public BaseChannel {
   ~VideoChannel();
 
   // downcasts a MediaChannel
-  VideoMediaSendChannelInterface* media_send_channel() const override {
+  VideoMediaSendChannelInterface* media_send_channel() override {
     return media_channel()->AsVideoChannel()->AsVideoSendChannel();
   }
 
-  VideoMediaSendChannelInterface* video_media_send_channel() const override {
+  VideoMediaSendChannelInterface* video_media_send_channel() override {
     return media_send_channel();
   }
 
   // downcasts a MediaChannel
-  VideoMediaReceiveChannelInterface* media_receive_channel() const override {
+  VideoMediaReceiveChannelInterface* media_receive_channel() override {
     return media_channel()->AsVideoChannel()->AsVideoReceiveChannel();
   }
 
-  VideoMediaReceiveChannelInterface* video_media_receive_channel()
-      const override {
+  VideoMediaReceiveChannelInterface* video_media_receive_channel() override {
     return media_receive_channel();
   }
 
@@ -474,6 +464,8 @@ class VideoChannel : public BaseChannel {
                           std::string& error_desc)
       RTC_RUN_ON(worker_thread()) override;
 
+  VideoMediaSendChannel send_channel_ RTC_GUARDED_BY(worker_thread());
+  VideoMediaReceiveChannel receive_channel_ RTC_GUARDED_BY(worker_thread());
   // Last VideoSendParameters sent down to the media_channel() via
   // SetSendParameters.
   VideoSendParameters last_send_params_ RTC_GUARDED_BY(worker_thread());
diff --git a/pc/channel_interface.h b/pc/channel_interface.h
index 445712b41f..c6474837fe 100644
--- a/pc/channel_interface.h
+++ b/pc/channel_interface.h
@@ -49,19 +49,17 @@ class ChannelInterface {
   virtual cricket::MediaType media_type() const = 0;
 
   // Temporary fix while MediaChannel is being reconstructed
-  virtual MediaChannel* media_channel() const = 0;
-  virtual MediaSendChannelInterface* media_send_channel() const = 0;
+  virtual MediaChannel* media_channel() = 0;
+  virtual MediaSendChannelInterface* media_send_channel() = 0;
   // Typecasts of media_channel(). Will cause an exception if the
   // channel is of the wrong type.
-  virtual VideoMediaSendChannelInterface* video_media_send_channel() const = 0;
-  virtual VoiceMediaSendChannelInterface* voice_media_send_channel() const = 0;
-  virtual MediaReceiveChannelInterface* media_receive_channel() const = 0;
+  virtual VideoMediaSendChannelInterface* video_media_send_channel() = 0;
+  virtual VoiceMediaSendChannelInterface* voice_media_send_channel() = 0;
+  virtual MediaReceiveChannelInterface* media_receive_channel() = 0;
   // Typecasts of media_channel(). Will cause an exception if the
   // channel is of the wrong type.
-  virtual VideoMediaReceiveChannelInterface* video_media_receive_channel()
-      const = 0;
-  virtual VoiceMediaReceiveChannelInterface* voice_media_receive_channel()
-      const = 0;
+  virtual VideoMediaReceiveChannelInterface* video_media_receive_channel() = 0;
+  virtual VoiceMediaReceiveChannelInterface* voice_media_receive_channel() = 0;
 
   // Returns a string view for the transport name. Fetching the transport name
   // must be done on the network thread only and note that the lifetime of
diff --git a/pc/channel_unittest.cc b/pc/channel_unittest.cc
index 583c2923df..27ad96aa3f 100644
--- a/pc/channel_unittest.cc
+++ b/pc/channel_unittest.cc
@@ -74,6 +74,8 @@ enum class NetworkIsWorker { Yes, No };
 
 template <class ChannelT,
           class MediaChannelT,
+          class MediaSendChannelT,
+          class MediaReceiveChannelT,
           class ContentT,
           class CodecT,
           class MediaInfoT,
@@ -82,6 +84,8 @@ class Traits {
  public:
   typedef ChannelT Channel;
   typedef MediaChannelT MediaChannel;
+  typedef MediaSendChannelT MediaSendChannel;
+  typedef MediaReceiveChannelT MediaReceiveChannel;
   typedef ContentT Content;
   typedef CodecT Codec;
   typedef MediaInfoT MediaInfo;
@@ -90,6 +94,8 @@ class Traits {
 
 class VoiceTraits : public Traits<cricket::VoiceChannel,
                                   cricket::FakeVoiceMediaChannel,
+                                  cricket::VoiceMediaSendChannelInterface,
+                                  cricket::VoiceMediaReceiveChannelInterface,
                                   cricket::AudioContentDescription,
                                   cricket::AudioCodec,
                                   cricket::VoiceMediaInfo,
@@ -97,6 +103,8 @@ class VoiceTraits : public Traits<cricket::VoiceChannel,
 
 class VideoTraits : public Traits<cricket::VideoChannel,
                                   cricket::FakeVideoMediaChannel,
+                                  cricket::VideoMediaSendChannelInterface,
+                                  cricket::VideoMediaReceiveChannelInterface,
                                   cricket::VideoContentDescription,
                                   cricket::VideoCodec,
                                   cricket::VideoMediaInfo,
@@ -429,7 +437,7 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
   }
 
   void SendRtp1(rtc::Buffer data) {
-    SendRtp(media_send_channel1(), std::move(data));
+    SendRtp(media_channel1(), std::move(data));
   }
 
   void SendRtp2() {
@@ -449,8 +457,7 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
   }
 
   bool CheckRtp1() {
-    return media_send_channel1()->CheckRtp(rtp_packet_.data(),
-                                           rtp_packet_.size());
+    return media_channel1()->CheckRtp(rtp_packet_.data(), rtp_packet_.size());
   }
   bool CheckRtp2() {
     return media_channel2()->CheckRtp(rtp_packet_.data(), rtp_packet_.size());
@@ -458,7 +465,7 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
   // Methods to check custom data.
   bool CheckCustomRtp1(uint32_t ssrc, int sequence_number, int pl_type = -1) {
     rtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type);
-    return media_send_channel1()->CheckRtp(data.data(), data.size());
+    return media_channel1()->CheckRtp(data.data(), data.size());
   }
   bool CheckCustomRtp2(uint32_t ssrc, int sequence_number, int pl_type = -1) {
     rtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type);
@@ -475,7 +482,7 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     return data;
   }
 
-  bool CheckNoRtp1() { return media_send_channel1()->CheckNoRtp(); }
+  bool CheckNoRtp1() { return media_channel1()->CheckNoRtp(); }
   bool CheckNoRtp2() { return media_channel2()->CheckNoRtp(); }
 
   void CreateContent(int flags,
@@ -558,13 +565,18 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
   void TestInit() {
     CreateChannels(0, 0);
     EXPECT_FALSE(IsSrtpActive(channel1_));
-    EXPECT_FALSE(media_send_channel1()->sending());
+    EXPECT_FALSE(media_channel1()->sending());
     if (verify_playout_) {
-      EXPECT_FALSE(media_send_channel1()->playout());
+      EXPECT_FALSE(media_channel1()->playout());
     }
-    EXPECT_TRUE(media_send_channel1()->codecs().empty());
-    EXPECT_TRUE(media_send_channel1()->recv_streams().empty());
-    EXPECT_TRUE(media_send_channel1()->rtp_packets().empty());
+    EXPECT_TRUE(media_channel1()->codecs().empty());
+    EXPECT_TRUE(media_channel1()->recv_streams().empty());
+    EXPECT_TRUE(media_channel1()->rtp_packets().empty());
+    // Basic sanity test for send and receive channel objects
+    EXPECT_EQ(channel1_->media_send_channel()->media_type(),
+              media_channel1()->media_type());
+    EXPECT_EQ(channel1_->media_receive_channel()->media_type(),
+              media_channel1()->media_type());
   }
 
   // Test that SetLocalContent and SetRemoteContent properly configure
@@ -575,11 +587,11 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
     std::string err;
     EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kOffer, err));
-    EXPECT_EQ(0U, media_send_channel1()->codecs().size());
+    EXPECT_EQ(0U, media_channel1()->codecs().size());
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, err));
-    ASSERT_EQ(1U, media_send_channel1()->codecs().size());
+    ASSERT_EQ(1U, media_channel1()->codecs().size());
     EXPECT_TRUE(
-        CodecMatches(content.codecs()[0], media_send_channel1()->codecs()[0]));
+        CodecMatches(content.codecs()[0], media_channel1()->codecs()[0]));
   }
 
   // Test that SetLocalContent and SetRemoteContent properly configure
@@ -623,11 +635,11 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     std::string err;
     EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kOffer, err));
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
-    EXPECT_EQ(0U, media_send_channel1()->codecs().size());
+    EXPECT_EQ(0U, media_channel1()->codecs().size());
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, err));
-    ASSERT_EQ(1U, media_send_channel1()->codecs().size());
+    ASSERT_EQ(1U, media_channel1()->codecs().size());
     EXPECT_TRUE(
-        CodecMatches(content.codecs()[0], media_send_channel1()->codecs()[0]));
+        CodecMatches(content.codecs()[0], media_channel1()->codecs()[0]));
   }
 
   // Test that SetLocalContent and SetRemoteContent properly set RTCP
@@ -669,7 +681,7 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     std::string err;
     EXPECT_TRUE(channel1_->SetLocalContent(&content1, SdpType::kOffer, err));
     channel1_->Enable(true);
-    EXPECT_EQ(1u, media_send_channel1()->send_streams().size());
+    EXPECT_EQ(1u, media_channel1()->send_streams().size());
 
     EXPECT_TRUE(channel2_->SetRemoteContent(&content1, SdpType::kOffer, err));
     EXPECT_EQ(1u, media_channel2()->recv_streams().size());
@@ -679,7 +691,7 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     typename T::Content content2;
     CreateContent(0, kPcmuCodec, kH264Codec, &content2);
     EXPECT_TRUE(channel1_->SetRemoteContent(&content2, SdpType::kAnswer, err));
-    EXPECT_EQ(0u, media_send_channel1()->recv_streams().size());
+    EXPECT_EQ(0u, media_channel1()->recv_streams().size());
     EXPECT_TRUE(channel2_->SetLocalContent(&content2, SdpType::kAnswer, err));
     channel2_->Enable(true);
     EXPECT_EQ(0u, media_channel2()->send_streams().size());
@@ -697,14 +709,14 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     EXPECT_EQ(stream2, media_channel2()->send_streams()[0]);
 
     EXPECT_TRUE(channel1_->SetRemoteContent(&content3, SdpType::kOffer, err));
-    ASSERT_EQ(1u, media_send_channel1()->recv_streams().size());
-    EXPECT_EQ(stream2, media_send_channel1()->recv_streams()[0]);
+    ASSERT_EQ(1u, media_channel1()->recv_streams().size());
+    EXPECT_EQ(stream2, media_channel1()->recv_streams()[0]);
 
     // Channel 1 replies but stop sending stream1.
     typename T::Content content4;
     CreateContent(0, kPcmuCodec, kH264Codec, &content4);
     EXPECT_TRUE(channel1_->SetLocalContent(&content4, SdpType::kAnswer, err));
-    EXPECT_EQ(0u, media_send_channel1()->send_streams().size());
+    EXPECT_EQ(0u, media_channel1()->send_streams().size());
 
     EXPECT_TRUE(channel2_->SetRemoteContent(&content4, SdpType::kAnswer, err));
     EXPECT_EQ(0u, media_channel2()->recv_streams().size());
@@ -718,9 +730,9 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
   void TestPlayoutAndSendingStates() {
     CreateChannels(0, 0);
     if (verify_playout_) {
-      EXPECT_FALSE(media_send_channel1()->playout());
+      EXPECT_FALSE(media_channel1()->playout());
     }
-    EXPECT_FALSE(media_send_channel1()->sending());
+    EXPECT_FALSE(media_channel1()->sending());
     if (verify_playout_) {
       EXPECT_FALSE(media_channel2()->playout());
     }
@@ -728,16 +740,16 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     channel1_->Enable(true);
     FlushCurrentThread();
     if (verify_playout_) {
-      EXPECT_FALSE(media_send_channel1()->playout());
+      EXPECT_FALSE(media_channel1()->playout());
     }
-    EXPECT_FALSE(media_send_channel1()->sending());
+    EXPECT_FALSE(media_channel1()->sending());
     std::string err;
     EXPECT_TRUE(channel1_->SetLocalContent(&local_media_content1_,
                                            SdpType::kOffer, err));
     if (verify_playout_) {
-      EXPECT_TRUE(media_send_channel1()->playout());
+      EXPECT_TRUE(media_channel1()->playout());
     }
-    EXPECT_FALSE(media_send_channel1()->sending());
+    EXPECT_FALSE(media_channel1()->sending());
     EXPECT_TRUE(channel2_->SetRemoteContent(&local_media_content1_,
                                             SdpType::kOffer, err));
     if (verify_playout_) {
@@ -752,9 +764,9 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     EXPECT_FALSE(media_channel2()->sending());
     ConnectFakeTransports();
     if (verify_playout_) {
-      EXPECT_TRUE(media_send_channel1()->playout());
+      EXPECT_TRUE(media_channel1()->playout());
     }
-    EXPECT_FALSE(media_send_channel1()->sending());
+    EXPECT_FALSE(media_channel1()->sending());
     if (verify_playout_) {
       EXPECT_FALSE(media_channel2()->playout());
     }
@@ -768,9 +780,9 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     EXPECT_TRUE(channel1_->SetRemoteContent(&local_media_content2_,
                                             SdpType::kAnswer, err));
     if (verify_playout_) {
-      EXPECT_TRUE(media_send_channel1()->playout());
+      EXPECT_TRUE(media_channel1()->playout());
     }
-    EXPECT_TRUE(media_send_channel1()->sending());
+    EXPECT_TRUE(media_channel1()->sending());
   }
 
   // Test that changing the MediaContentDirection in the local and remote
@@ -788,9 +800,9 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     channel2_->Enable(true);
     FlushCurrentThread();
     if (verify_playout_) {
-      EXPECT_FALSE(media_send_channel1()->playout());
+      EXPECT_FALSE(media_channel1()->playout());
     }
-    EXPECT_FALSE(media_send_channel1()->sending());
+    EXPECT_FALSE(media_channel1()->sending());
     if (verify_playout_) {
       EXPECT_FALSE(media_channel2()->playout());
     }
@@ -805,9 +817,9 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     ConnectFakeTransports();
 
     if (verify_playout_) {
-      EXPECT_TRUE(media_send_channel1()->playout());
+      EXPECT_TRUE(media_channel1()->playout());
     }
-    EXPECT_FALSE(media_send_channel1()->sending());  // remote InActive
+    EXPECT_FALSE(media_channel1()->sending());  // remote InActive
     if (verify_playout_) {
       EXPECT_FALSE(media_channel2()->playout());  // local InActive
     }
@@ -820,9 +832,9 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
         channel1_->SetRemoteContent(&content2, SdpType::kPrAnswer, err));
 
     if (verify_playout_) {
-      EXPECT_TRUE(media_send_channel1()->playout());
+      EXPECT_TRUE(media_channel1()->playout());
     }
-    EXPECT_TRUE(media_send_channel1()->sending());
+    EXPECT_TRUE(media_channel1()->sending());
     if (verify_playout_) {
       EXPECT_TRUE(media_channel2()->playout());  // local RecvOnly
     }
@@ -834,9 +846,9 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     EXPECT_TRUE(channel1_->SetRemoteContent(&content2, SdpType::kAnswer, err));
 
     if (verify_playout_) {
-      EXPECT_TRUE(media_send_channel1()->playout());
+      EXPECT_TRUE(media_channel1()->playout());
     }
-    EXPECT_TRUE(media_send_channel1()->sending());
+    EXPECT_TRUE(media_channel1()->sending());
     if (verify_playout_) {
       EXPECT_TRUE(media_channel2()->playout());
     }
@@ -856,15 +868,14 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     CreateChannels(DTLS, DTLS);
     SendInitiate();
 
-    typename T::MediaChannel* media_send_channel1 =
-        static_cast<typename T::MediaChannel*>(channel1_->media_send_channel());
-    ASSERT_TRUE(media_send_channel1);
+    typename T::MediaChannel* media_channel1 = this->media_channel1();
+    ASSERT_TRUE(media_channel1);
 
     // Need to wait for the threads before calling
     // `set_num_network_route_changes` because the network route would be set
     // when creating the channel.
     WaitForThreads();
-    media_send_channel1->set_num_network_route_changes(0);
+    media_channel1->set_num_network_route_changes(0);
     SendTask(network_thread_, [this] {
       rtc::NetworkRoute network_route;
       // The transport channel becomes disconnected.
@@ -872,9 +883,9 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
           absl::optional<rtc::NetworkRoute>(network_route));
     });
     WaitForThreads();
-    EXPECT_EQ(1, media_send_channel1->num_network_route_changes());
-    EXPECT_FALSE(media_send_channel1->last_network_route().connected);
-    media_send_channel1->set_num_network_route_changes(0);
+    EXPECT_EQ(1, media_channel1->num_network_route_changes());
+    EXPECT_FALSE(media_channel1->last_network_route().connected);
+    media_channel1->set_num_network_route_changes(0);
 
     SendTask(network_thread_, [this] {
       rtc::NetworkRoute network_route;
@@ -891,16 +902,16 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
           absl::optional<rtc::NetworkRoute>(network_route));
     });
     WaitForThreads();
-    EXPECT_EQ(1, media_send_channel1->num_network_route_changes());
-    EXPECT_TRUE(media_send_channel1->last_network_route().connected);
+    EXPECT_EQ(1, media_channel1->num_network_route_changes());
+    EXPECT_TRUE(media_channel1->last_network_route().connected);
     EXPECT_EQ(kLocalNetId,
-              media_send_channel1->last_network_route().local.network_id());
+              media_channel1->last_network_route().local.network_id());
     EXPECT_EQ(kRemoteNetId,
-              media_send_channel1->last_network_route().remote.network_id());
+              media_channel1->last_network_route().remote.network_id());
     EXPECT_EQ(kLastPacketId,
-              media_send_channel1->last_network_route().last_sent_packet_id);
+              media_channel1->last_network_route().last_sent_packet_id);
     EXPECT_EQ(kTransportOverheadPerPacket + kSrtpOverheadPerPacket,
-              media_send_channel1->transport_overhead_per_packet());
+              media_channel1->transport_overhead_per_packet());
   }
 
   // Test setting up a call.
@@ -909,13 +920,13 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     EXPECT_FALSE(IsSrtpActive(channel1_));
     EXPECT_TRUE(SendInitiate());
     if (verify_playout_) {
-      EXPECT_TRUE(media_send_channel1()->playout());
+      EXPECT_TRUE(media_channel1()->playout());
     }
-    EXPECT_FALSE(media_send_channel1()->sending());
+    EXPECT_FALSE(media_channel1()->sending());
     EXPECT_TRUE(SendAccept());
     EXPECT_FALSE(IsSrtpActive(channel1_));
-    EXPECT_TRUE(media_send_channel1()->sending());
-    EXPECT_EQ(1U, media_send_channel1()->codecs().size());
+    EXPECT_TRUE(media_channel1()->sending());
+    EXPECT_EQ(1U, media_channel1()->codecs().size());
     if (verify_playout_) {
       EXPECT_TRUE(media_channel2()->playout());
     }
@@ -1047,7 +1058,7 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     // Regain writability
     SendTask(network_thread_,
              [this] { fake_rtp_dtls_transport1_->SetWritable(true); });
-    EXPECT_TRUE(media_send_channel1()->sending());
+    EXPECT_TRUE(media_channel1()->sending());
     SendRtp1();
     SendRtp2();
     WaitForThreads();
@@ -1061,7 +1072,7 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
       bool asymmetric = true;
       fake_rtp_dtls_transport1_->SetDestination(nullptr, asymmetric);
     });
-    EXPECT_TRUE(media_send_channel1()->sending());
+    EXPECT_TRUE(media_channel1()->sending());
 
     // Should fail also.
     SendRtp1();
@@ -1077,7 +1088,7 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
       fake_rtp_dtls_transport1_->SetDestination(fake_rtp_dtls_transport2_.get(),
                                                 asymmetric);
     });
-    EXPECT_TRUE(media_send_channel1()->sending());
+    EXPECT_TRUE(media_channel1()->sending());
     SendRtp1();
     SendRtp2();
     WaitForThreads();
@@ -1130,17 +1141,17 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     std::unique_ptr<typename T::Content> content(
         CreateMediaContentWithStream(1));
 
-    media_send_channel1()->set_fail_set_recv_codecs(true);
+    media_channel1()->set_fail_set_recv_codecs(true);
     EXPECT_FALSE(
         channel1_->SetLocalContent(content.get(), SdpType::kOffer, err));
     EXPECT_FALSE(
         channel1_->SetLocalContent(content.get(), SdpType::kAnswer, err));
 
-    media_send_channel1()->set_fail_set_send_codecs(true);
+    media_channel1()->set_fail_set_send_codecs(true);
     EXPECT_FALSE(
         channel1_->SetRemoteContent(content.get(), SdpType::kOffer, err));
 
-    media_send_channel1()->set_fail_set_send_codecs(true);
+    media_channel1()->set_fail_set_send_codecs(true);
     EXPECT_FALSE(
         channel1_->SetRemoteContent(content.get(), SdpType::kAnswer, err));
   }
@@ -1153,14 +1164,14 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
         CreateMediaContentWithStream(1));
     EXPECT_TRUE(
         channel1_->SetLocalContent(content1.get(), SdpType::kOffer, err));
-    EXPECT_TRUE(media_send_channel1()->HasSendStream(1));
+    EXPECT_TRUE(media_channel1()->HasSendStream(1));
 
     std::unique_ptr<typename T::Content> content2(
         CreateMediaContentWithStream(2));
     EXPECT_TRUE(
         channel1_->SetLocalContent(content2.get(), SdpType::kOffer, err));
-    EXPECT_FALSE(media_send_channel1()->HasSendStream(1));
-    EXPECT_TRUE(media_send_channel1()->HasSendStream(2));
+    EXPECT_FALSE(media_channel1()->HasSendStream(1));
+    EXPECT_TRUE(media_channel1()->HasSendStream(2));
   }
 
   void TestReceiveTwoOffers() {
@@ -1171,14 +1182,14 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
         CreateMediaContentWithStream(1));
     EXPECT_TRUE(
         channel1_->SetRemoteContent(content1.get(), SdpType::kOffer, err));
-    EXPECT_TRUE(media_send_channel1()->HasRecvStream(1));
+    EXPECT_TRUE(media_channel1()->HasRecvStream(1));
 
     std::unique_ptr<typename T::Content> content2(
         CreateMediaContentWithStream(2));
     EXPECT_TRUE(
         channel1_->SetRemoteContent(content2.get(), SdpType::kOffer, err));
-    EXPECT_FALSE(media_send_channel1()->HasRecvStream(1));
-    EXPECT_TRUE(media_send_channel1()->HasRecvStream(2));
+    EXPECT_FALSE(media_channel1()->HasRecvStream(1));
+    EXPECT_TRUE(media_channel1()->HasRecvStream(2));
   }
 
   void TestSendPrAnswer() {
@@ -1190,24 +1201,24 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
         CreateMediaContentWithStream(1));
     EXPECT_TRUE(
         channel1_->SetRemoteContent(content1.get(), SdpType::kOffer, err));
-    EXPECT_TRUE(media_send_channel1()->HasRecvStream(1));
+    EXPECT_TRUE(media_channel1()->HasRecvStream(1));
 
     // Send PR answer
     std::unique_ptr<typename T::Content> content2(
         CreateMediaContentWithStream(2));
     EXPECT_TRUE(
         channel1_->SetLocalContent(content2.get(), SdpType::kPrAnswer, err));
-    EXPECT_TRUE(media_send_channel1()->HasRecvStream(1));
-    EXPECT_TRUE(media_send_channel1()->HasSendStream(2));
+    EXPECT_TRUE(media_channel1()->HasRecvStream(1));
+    EXPECT_TRUE(media_channel1()->HasSendStream(2));
 
     // Send answer
     std::unique_ptr<typename T::Content> content3(
         CreateMediaContentWithStream(3));
     EXPECT_TRUE(
         channel1_->SetLocalContent(content3.get(), SdpType::kAnswer, err));
-    EXPECT_TRUE(media_send_channel1()->HasRecvStream(1));
-    EXPECT_FALSE(media_send_channel1()->HasSendStream(2));
-    EXPECT_TRUE(media_send_channel1()->HasSendStream(3));
+    EXPECT_TRUE(media_channel1()->HasRecvStream(1));
+    EXPECT_FALSE(media_channel1()->HasSendStream(2));
+    EXPECT_TRUE(media_channel1()->HasSendStream(3));
   }
 
   void TestReceivePrAnswer() {
@@ -1219,39 +1230,39 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
         CreateMediaContentWithStream(1));
     EXPECT_TRUE(
         channel1_->SetLocalContent(content1.get(), SdpType::kOffer, err));
-    EXPECT_TRUE(media_send_channel1()->HasSendStream(1));
+    EXPECT_TRUE(media_channel1()->HasSendStream(1));
 
     // Receive PR answer
     std::unique_ptr<typename T::Content> content2(
         CreateMediaContentWithStream(2));
     EXPECT_TRUE(
         channel1_->SetRemoteContent(content2.get(), SdpType::kPrAnswer, err));
-    EXPECT_TRUE(media_send_channel1()->HasSendStream(1));
-    EXPECT_TRUE(media_send_channel1()->HasRecvStream(2));
+    EXPECT_TRUE(media_channel1()->HasSendStream(1));
+    EXPECT_TRUE(media_channel1()->HasRecvStream(2));
 
     // Receive answer
     std::unique_ptr<typename T::Content> content3(
         CreateMediaContentWithStream(3));
     EXPECT_TRUE(
         channel1_->SetRemoteContent(content3.get(), SdpType::kAnswer, err));
-    EXPECT_TRUE(media_send_channel1()->HasSendStream(1));
-    EXPECT_FALSE(media_send_channel1()->HasRecvStream(2));
-    EXPECT_TRUE(media_send_channel1()->HasRecvStream(3));
+    EXPECT_TRUE(media_channel1()->HasSendStream(1));
+    EXPECT_FALSE(media_channel1()->HasRecvStream(2));
+    EXPECT_TRUE(media_channel1()->HasRecvStream(3));
   }
 
   void TestOnTransportReadyToSend() {
     CreateChannels(0, 0);
-    EXPECT_FALSE(media_send_channel1()->ready_to_send());
+    EXPECT_FALSE(media_channel1()->ready_to_send());
 
     network_thread_->PostTask(
         [this] { channel1_->OnTransportReadyToSend(true); });
     WaitForThreads();
-    EXPECT_TRUE(media_send_channel1()->ready_to_send());
+    EXPECT_TRUE(media_channel1()->ready_to_send());
 
     network_thread_->PostTask(
         [this] { channel1_->OnTransportReadyToSend(false); });
     WaitForThreads();
-    EXPECT_FALSE(media_send_channel1()->ready_to_send());
+    EXPECT_FALSE(media_channel1()->ready_to_send());
   }
 
   bool SetRemoteContentWithBitrateLimit(int remote_limit) {
@@ -1280,7 +1291,7 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     std::string err;
     EXPECT_TRUE(channel1_->SetLocalContent(&local_media_content1_,
                                            SdpType::kOffer, err));
-    EXPECT_EQ(media_send_channel1()->max_bps(), -1);
+    EXPECT_EQ(media_channel1()->max_bps(), -1);
     VerifyMaxBitrate(media_send_channel1()->GetRtpSendParameters(kSsrc1),
                      absl::nullopt);
   }
@@ -1398,18 +1409,31 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     ProcessThreadQueue(rtc::Thread::Current());
   }
 
-  typename T::MediaChannel* media_send_channel1() {
+  // Accessors that return the FakeMedia<type>Channel object.
+  // Note that these depend on getting the object back that was
+  // passed to the channel constructor.
+  typename T::MediaChannel* media_channel1() {
     RTC_DCHECK(channel1_);
-    RTC_DCHECK(channel1_->media_send_channel());
-    return static_cast<typename T::MediaChannel*>(
-        channel1_->media_send_channel());
+    RTC_DCHECK(channel1_->media_channel());
+    return static_cast<typename T::MediaChannel*>(channel1_->media_channel());
   }
 
   typename T::MediaChannel* media_channel2() {
+    RTC_DCHECK(channel2_);
+    RTC_DCHECK(channel2_->media_channel());
+    return static_cast<typename T::MediaChannel*>(channel2_->media_channel());
+  }
+
+  typename T::MediaSendChannel* media_send_channel1() {
+    RTC_DCHECK(channel1_);
+    RTC_DCHECK(channel1_->media_send_channel());
+    return channel1_->media_send_channel();
+  }
+
+  typename T::MediaSendChannel* media_send_channel2() {
     RTC_DCHECK(channel2_);
     RTC_DCHECK(channel2_->media_send_channel());
-    return static_cast<typename T::MediaChannel*>(
-        channel2_->media_send_channel());
+    return channel2_->media_send_channel();
   }
 
   rtc::AutoThread main_thread_;
@@ -1598,8 +1622,8 @@ class VideoChannelDoubleThreadTest : public ChannelTest<VideoTraits> {
 
 TEST_F(VoiceChannelSingleThreadTest, TestInit) {
   Base::TestInit();
-  EXPECT_FALSE(media_send_channel1()->IsStreamMuted(0));
-  EXPECT_TRUE(media_send_channel1()->dtmf_info_queue().empty());
+  EXPECT_FALSE(media_channel1()->IsStreamMuted(0));
+  EXPECT_TRUE(media_channel1()->dtmf_info_queue().empty());
 }
 
 TEST_F(VoiceChannelSingleThreadTest, TestDeinit) {
@@ -1735,8 +1759,8 @@ TEST_F(VoiceChannelSingleThreadTest, SocketOptionsMergedOnSetTransport) {
 // VoiceChannelDoubleThreadTest
 TEST_F(VoiceChannelDoubleThreadTest, TestInit) {
   Base::TestInit();
-  EXPECT_FALSE(media_send_channel1()->IsStreamMuted(0));
-  EXPECT_TRUE(media_send_channel1()->dtmf_info_queue().empty());
+  EXPECT_FALSE(media_channel1()->IsStreamMuted(0));
+  EXPECT_TRUE(media_channel1()->dtmf_info_queue().empty());
 }
 
 TEST_F(VoiceChannelDoubleThreadTest, TestDeinit) {
@@ -2019,15 +2043,14 @@ TEST_F(VideoChannelSingleThreadTest, TestSetLocalOfferWithPacketization) {
 
   std::string err;
   EXPECT_TRUE(channel1_->SetLocalContent(&video, SdpType::kOffer, err));
-  EXPECT_THAT(media_send_channel1()->send_codecs(), testing::IsEmpty());
-  ASSERT_THAT(media_send_channel1()->recv_codecs(), testing::SizeIs(2));
-  EXPECT_TRUE(media_send_channel1()->recv_codecs()[0].Matches(kVp8Codec,
-                                                              &field_trials_));
-  EXPECT_EQ(media_send_channel1()->recv_codecs()[0].packetization,
-            absl::nullopt);
-  EXPECT_TRUE(media_send_channel1()->recv_codecs()[1].Matches(vp9_codec,
-                                                              &field_trials_));
-  EXPECT_EQ(media_send_channel1()->recv_codecs()[1].packetization,
+  EXPECT_THAT(media_channel1()->send_codecs(), testing::IsEmpty());
+  ASSERT_THAT(media_channel1()->recv_codecs(), testing::SizeIs(2));
+  EXPECT_TRUE(
+      media_channel1()->recv_codecs()[0].Matches(kVp8Codec, &field_trials_));
+  EXPECT_EQ(media_channel1()->recv_codecs()[0].packetization, absl::nullopt);
+  EXPECT_TRUE(
+      media_channel1()->recv_codecs()[1].Matches(vp9_codec, &field_trials_));
+  EXPECT_EQ(media_channel1()->recv_codecs()[1].packetization,
             cricket::kPacketizationParamRaw);
 }
 
@@ -2043,15 +2066,14 @@ TEST_F(VideoChannelSingleThreadTest, TestSetRemoteOfferWithPacketization) {
   std::string err;
   EXPECT_TRUE(channel1_->SetRemoteContent(&video, SdpType::kOffer, err));
   EXPECT_TRUE(err.empty());
-  EXPECT_THAT(media_send_channel1()->recv_codecs(), testing::IsEmpty());
-  ASSERT_THAT(media_send_channel1()->send_codecs(), testing::SizeIs(2));
-  EXPECT_TRUE(media_send_channel1()->send_codecs()[0].Matches(kVp8Codec,
-                                                              &field_trials_));
-  EXPECT_EQ(media_send_channel1()->send_codecs()[0].packetization,
-            absl::nullopt);
-  EXPECT_TRUE(media_send_channel1()->send_codecs()[1].Matches(vp9_codec,
-                                                              &field_trials_));
-  EXPECT_EQ(media_send_channel1()->send_codecs()[1].packetization,
+  EXPECT_THAT(media_channel1()->recv_codecs(), testing::IsEmpty());
+  ASSERT_THAT(media_channel1()->send_codecs(), testing::SizeIs(2));
+  EXPECT_TRUE(
+      media_channel1()->send_codecs()[0].Matches(kVp8Codec, &field_trials_));
+  EXPECT_EQ(media_channel1()->send_codecs()[0].packetization, absl::nullopt);
+  EXPECT_TRUE(
+      media_channel1()->send_codecs()[1].Matches(vp9_codec, &field_trials_));
+  EXPECT_EQ(media_channel1()->send_codecs()[1].packetization,
             cricket::kPacketizationParamRaw);
 }
 
@@ -2069,23 +2091,21 @@ TEST_F(VideoChannelSingleThreadTest, TestSetAnswerWithPacketization) {
   EXPECT_TRUE(err.empty());
   EXPECT_TRUE(channel1_->SetRemoteContent(&video, SdpType::kAnswer, err));
   EXPECT_TRUE(err.empty());
-  ASSERT_THAT(media_send_channel1()->recv_codecs(), testing::SizeIs(2));
-  EXPECT_TRUE(media_send_channel1()->recv_codecs()[0].Matches(kVp8Codec,
-                                                              &field_trials_));
-  EXPECT_EQ(media_send_channel1()->recv_codecs()[0].packetization,
-            absl::nullopt);
-  EXPECT_TRUE(media_send_channel1()->recv_codecs()[1].Matches(vp9_codec,
-                                                              &field_trials_));
-  EXPECT_EQ(media_send_channel1()->recv_codecs()[1].packetization,
+  ASSERT_THAT(media_channel1()->recv_codecs(), testing::SizeIs(2));
+  EXPECT_TRUE(
+      media_channel1()->recv_codecs()[0].Matches(kVp8Codec, &field_trials_));
+  EXPECT_EQ(media_channel1()->recv_codecs()[0].packetization, absl::nullopt);
+  EXPECT_TRUE(
+      media_channel1()->recv_codecs()[1].Matches(vp9_codec, &field_trials_));
+  EXPECT_EQ(media_channel1()->recv_codecs()[1].packetization,
             cricket::kPacketizationParamRaw);
-  EXPECT_THAT(media_send_channel1()->send_codecs(), testing::SizeIs(2));
-  EXPECT_TRUE(media_send_channel1()->send_codecs()[0].Matches(kVp8Codec,
-                                                              &field_trials_));
-  EXPECT_EQ(media_send_channel1()->send_codecs()[0].packetization,
-            absl::nullopt);
-  EXPECT_TRUE(media_send_channel1()->send_codecs()[1].Matches(vp9_codec,
-                                                              &field_trials_));
-  EXPECT_EQ(media_send_channel1()->send_codecs()[1].packetization,
+  EXPECT_THAT(media_channel1()->send_codecs(), testing::SizeIs(2));
+  EXPECT_TRUE(
+      media_channel1()->send_codecs()[0].Matches(kVp8Codec, &field_trials_));
+  EXPECT_EQ(media_channel1()->send_codecs()[0].packetization, absl::nullopt);
+  EXPECT_TRUE(
+      media_channel1()->send_codecs()[1].Matches(vp9_codec, &field_trials_));
+  EXPECT_EQ(media_channel1()->send_codecs()[1].packetization,
             cricket::kPacketizationParamRaw);
 }
 
@@ -2103,12 +2123,10 @@ TEST_F(VideoChannelSingleThreadTest, TestSetLocalAnswerWithoutPacketization) {
   std::string err;
   EXPECT_TRUE(channel1_->SetRemoteContent(&remote_video, SdpType::kOffer, err));
   EXPECT_TRUE(channel1_->SetLocalContent(&local_video, SdpType::kAnswer, err));
-  ASSERT_THAT(media_send_channel1()->recv_codecs(), testing::SizeIs(1));
-  EXPECT_EQ(media_send_channel1()->recv_codecs()[0].packetization,
-            absl::nullopt);
-  ASSERT_THAT(media_send_channel1()->send_codecs(), testing::SizeIs(1));
-  EXPECT_EQ(media_send_channel1()->send_codecs()[0].packetization,
-            absl::nullopt);
+  ASSERT_THAT(media_channel1()->recv_codecs(), testing::SizeIs(1));
+  EXPECT_EQ(media_channel1()->recv_codecs()[0].packetization, absl::nullopt);
+  ASSERT_THAT(media_channel1()->send_codecs(), testing::SizeIs(1));
+  EXPECT_EQ(media_channel1()->send_codecs()[0].packetization, absl::nullopt);
 }
 
 TEST_F(VideoChannelSingleThreadTest, TestSetRemoteAnswerWithoutPacketization) {
@@ -2126,12 +2144,10 @@ TEST_F(VideoChannelSingleThreadTest, TestSetRemoteAnswerWithoutPacketization) {
   EXPECT_TRUE(channel1_->SetLocalContent(&local_video, SdpType::kOffer, err));
   EXPECT_TRUE(
       channel1_->SetRemoteContent(&remote_video, SdpType::kAnswer, err));
-  ASSERT_THAT(media_send_channel1()->recv_codecs(), testing::SizeIs(1));
-  EXPECT_EQ(media_send_channel1()->recv_codecs()[0].packetization,
-            absl::nullopt);
-  ASSERT_THAT(media_send_channel1()->send_codecs(), testing::SizeIs(1));
-  EXPECT_EQ(media_send_channel1()->send_codecs()[0].packetization,
-            absl::nullopt);
+  ASSERT_THAT(media_channel1()->recv_codecs(), testing::SizeIs(1));
+  EXPECT_EQ(media_channel1()->recv_codecs()[0].packetization, absl::nullopt);
+  ASSERT_THAT(media_channel1()->send_codecs(), testing::SizeIs(1));
+  EXPECT_EQ(media_channel1()->send_codecs()[0].packetization, absl::nullopt);
 }
 
 TEST_F(VideoChannelSingleThreadTest,
@@ -2153,10 +2169,10 @@ TEST_F(VideoChannelSingleThreadTest,
   EXPECT_FALSE(
       channel1_->SetRemoteContent(&remote_video, SdpType::kAnswer, err));
   EXPECT_FALSE(err.empty());
-  ASSERT_THAT(media_send_channel1()->recv_codecs(), testing::SizeIs(1));
-  EXPECT_EQ(media_send_channel1()->recv_codecs()[0].packetization,
+  ASSERT_THAT(media_channel1()->recv_codecs(), testing::SizeIs(1));
+  EXPECT_EQ(media_channel1()->recv_codecs()[0].packetization,
             cricket::kPacketizationParamRaw);
-  EXPECT_THAT(media_send_channel1()->send_codecs(), testing::IsEmpty());
+  EXPECT_THAT(media_channel1()->send_codecs(), testing::IsEmpty());
 }
 
 TEST_F(VideoChannelSingleThreadTest,
@@ -2176,10 +2192,9 @@ TEST_F(VideoChannelSingleThreadTest,
   EXPECT_TRUE(err.empty());
   EXPECT_FALSE(channel1_->SetLocalContent(&local_video, SdpType::kAnswer, err));
   EXPECT_FALSE(err.empty());
-  EXPECT_THAT(media_send_channel1()->recv_codecs(), testing::IsEmpty());
-  ASSERT_THAT(media_send_channel1()->send_codecs(), testing::SizeIs(1));
-  EXPECT_EQ(media_send_channel1()->send_codecs()[0].packetization,
-            absl::nullopt);
+  EXPECT_THAT(media_channel1()->recv_codecs(), testing::IsEmpty());
+  ASSERT_THAT(media_channel1()->send_codecs(), testing::SizeIs(1));
+  EXPECT_EQ(media_channel1()->send_codecs()[0].packetization, absl::nullopt);
 }
 
 // VideoChannelDoubleThreadTest
diff --git a/pc/rtc_stats_collector.cc b/pc/rtc_stats_collector.cc
index d500a7bf1d..a9fb3b7d76 100644
--- a/pc/rtc_stats_collector.cc
+++ b/pc/rtc_stats_collector.cc
@@ -2366,15 +2366,13 @@ void RTCStatsCollector::PrepareTransceiverStatsInfosAndCallStats_s_w_n() {
 
       if (media_type == cricket::MEDIA_TYPE_AUDIO) {
         cricket::VoiceMediaChannel* voice_channel =
-            static_cast<cricket::VoiceMediaChannel*>(
-                channel->voice_media_send_channel());
+            channel->media_channel()->AsVoiceChannel();
         RTC_DCHECK(voice_stats.find(voice_channel) == voice_stats.end());
         voice_stats.insert(
             std::make_pair(voice_channel, cricket::VoiceMediaInfo()));
       } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
         cricket::VideoMediaChannel* video_channel =
-            static_cast<cricket::VideoMediaChannel*>(
-                channel->video_media_send_channel());
+            channel->media_channel()->AsVideoChannel();
         RTC_DCHECK(video_stats.find(video_channel) == video_stats.end());
         video_stats.insert(
             std::make_pair(video_channel, cricket::VideoMediaInfo()));
@@ -2413,14 +2411,12 @@ void RTCStatsCollector::PrepareTransceiverStatsInfosAndCallStats_s_w_n() {
         cricket::MediaType media_type = transceiver->media_type();
         if (media_type == cricket::MEDIA_TYPE_AUDIO) {
           cricket::VoiceMediaChannel* voice_channel =
-              static_cast<cricket::VoiceMediaChannel*>(
-                  channel->voice_media_send_channel());
+              channel->media_channel()->AsVoiceChannel();
           RTC_DCHECK(voice_stats.find(voice_channel) != voice_stats.end());
           voice_media_info = std::move(voice_stats[voice_channel]);
         } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
           cricket::VideoMediaChannel* video_channel =
-              static_cast<cricket::VideoMediaChannel*>(
-                  channel->video_media_send_channel());
+              channel->media_channel()->AsVideoChannel();
           RTC_DCHECK(video_stats.find(video_channel) != video_stats.end());
           video_media_info = std::move(video_stats[video_channel]);
         }
diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc
index a189e6517b..e51b058210 100644
--- a/pc/rtp_sender_receiver_unittest.cc
+++ b/pc/rtp_sender_receiver_unittest.cc
@@ -130,6 +130,11 @@ class RtpSenderReceiverTest
 
     RTC_CHECK(voice_media_channel());
     RTC_CHECK(video_media_channel());
+    // Create sender channel objects
+    voice_send_channel_ =
+        std::make_unique<cricket::VoiceMediaSendChannel>(voice_media_channel());
+    video_send_channel_ =
+        std::make_unique<cricket::VideoMediaSendChannel>(video_media_channel());
 
     // Create streams for predefined SSRCs. Streams need to exist in order
     // for the senders and receievers to apply parameters to them.
@@ -204,7 +209,7 @@ class RtpSenderReceiverTest
     ASSERT_TRUE(audio_rtp_sender_->SetTrack(audio_track_.get()));
     EXPECT_CALL(*set_streams_observer, OnSetStreams());
     audio_rtp_sender_->SetStreams({local_stream_->id()});
-    audio_rtp_sender_->SetMediaChannel(voice_media_channel()->AsSendChannel());
+    audio_rtp_sender_->SetMediaChannel(voice_send_channel_.get());
     audio_rtp_sender_->SetSsrc(kAudioSsrc);
     VerifyVoiceChannelInput();
   }
@@ -520,6 +525,8 @@ class RtpSenderReceiverTest
   cricket::FakeCall fake_call_;
   std::unique_ptr<cricket::FakeVoiceMediaChannel> voice_media_channel_;
   std::unique_ptr<cricket::FakeVideoMediaChannel> video_media_channel_;
+  std::unique_ptr<cricket::VoiceMediaSendChannel> voice_send_channel_;
+  std::unique_ptr<cricket::VideoMediaSendChannel> video_send_channel_;
   rtc::scoped_refptr<AudioRtpSender> audio_rtp_sender_;
   rtc::scoped_refptr<VideoRtpSender> video_rtp_sender_;
   rtc::scoped_refptr<AudioRtpReceiver> audio_rtp_receiver_;
diff --git a/pc/test/mock_channel_interface.h b/pc/test/mock_channel_interface.h
index 273e4a19f0..229fb57a2e 100644
--- a/pc/test/mock_channel_interface.h
+++ b/pc/test/mock_channel_interface.h
@@ -25,25 +25,13 @@ namespace cricket {
 class MockChannelInterface : public cricket::ChannelInterface {
  public:
   MOCK_METHOD(cricket::MediaType, media_type, (), (const, override));
-  MOCK_METHOD(MediaChannel*, media_channel, (), (const, override));
-  MOCK_METHOD(MediaChannel*, media_send_channel, (), (const, override));
-  MOCK_METHOD(VoiceMediaChannel*,
-              voice_media_send_channel,
-              (),
-              (const, override));
-  MOCK_METHOD(VideoMediaChannel*,
-              video_media_send_channel,
-              (),
-              (const, override));
-  MOCK_METHOD(MediaChannel*, media_receive_channel, (), (const, override));
-  MOCK_METHOD(VoiceMediaChannel*,
-              voice_media_receive_channel,
-              (),
-              (const, override));
-  MOCK_METHOD(VideoMediaChannel*,
-              video_media_receive_channel,
-              (),
-              (const, override));
+  MOCK_METHOD(MediaChannel*, media_channel, (), (override));
+  MOCK_METHOD(MediaChannel*, media_send_channel, (), (override));
+  MOCK_METHOD(VoiceMediaChannel*, voice_media_send_channel, (), (override));
+  MOCK_METHOD(VideoMediaChannel*, video_media_send_channel, (), (override));
+  MOCK_METHOD(MediaChannel*, media_receive_channel, (), (override));
+  MOCK_METHOD(VoiceMediaChannel*, voice_media_receive_channel, (), (override));
+  MOCK_METHOD(VideoMediaChannel*, video_media_receive_channel, (), (override));
   MOCK_METHOD(absl::string_view, transport_name, (), (const, override));
   MOCK_METHOD(const std::string&, mid, (), (const, override));
   MOCK_METHOD(void, Enable, (bool), (override));