diff --git a/media/BUILD.gn b/media/BUILD.gn
index dd698af8a4..3ecc881f31 100644
--- a/media/BUILD.gn
+++ b/media/BUILD.gn
@@ -737,6 +737,7 @@ if (rtc_include_tests) {
     deps = [
       ":codec",
       ":media_channel",
+      ":media_channel_impl",
       ":media_constants",
       ":rtc_audio_video",
       ":rtc_internal_video_codecs",
@@ -747,6 +748,7 @@ if (rtc_include_tests) {
       ":stream_params",
       "../api:call_api",
       "../api:fec_controller_api",
+      "../api:rtp_parameters",
       "../api:scoped_refptr",
       "../api/task_queue",
       "../api/task_queue:pending_task_safety_flag",
@@ -790,6 +792,7 @@ if (rtc_include_tests) {
     ]
     absl_deps = [
       "//third_party/abseil-cpp/absl/algorithm:container",
+      "//third_party/abseil-cpp/absl/functional:any_invocable",
       "//third_party/abseil-cpp/absl/strings",
       "//third_party/abseil-cpp/absl/types:optional",
     ]
diff --git a/media/base/fake_media_engine.cc b/media/base/fake_media_engine.cc
index e31ffad3a6..02d94aae80 100644
--- a/media/base/fake_media_engine.cc
+++ b/media/base/fake_media_engine.cc
@@ -16,109 +16,246 @@
 #include "absl/algorithm/container.h"
 #include "absl/strings/match.h"
 #include "absl/types/optional.h"
+#include "media/base/media_channel.h"
 #include "rtc_base/checks.h"
 
 namespace cricket {
 using webrtc::TaskQueueBase;
 
-FakeVoiceMediaChannel::DtmfInfo::DtmfInfo(uint32_t ssrc,
-                                          int event_code,
-                                          int duration)
+FakeVoiceMediaReceiveChannel::DtmfInfo::DtmfInfo(uint32_t ssrc,
+                                                 int event_code,
+                                                 int duration)
     : ssrc(ssrc), event_code(event_code), duration(duration) {}
 
-FakeVoiceMediaChannel::VoiceChannelAudioSink::VoiceChannelAudioSink(
+FakeVoiceMediaReceiveChannel::VoiceChannelAudioSink::VoiceChannelAudioSink(
     AudioSource* source)
     : source_(source) {
   source_->SetSink(this);
 }
-FakeVoiceMediaChannel::VoiceChannelAudioSink::~VoiceChannelAudioSink() {
+FakeVoiceMediaReceiveChannel::VoiceChannelAudioSink::~VoiceChannelAudioSink() {
   if (source_) {
     source_->SetSink(nullptr);
   }
 }
-void FakeVoiceMediaChannel::VoiceChannelAudioSink::OnData(
+void FakeVoiceMediaReceiveChannel::VoiceChannelAudioSink::OnData(
     const void* audio_data,
     int bits_per_sample,
     int sample_rate,
     size_t number_of_channels,
     size_t number_of_frames,
     absl::optional<int64_t> absolute_capture_timestamp_ms) {}
-void FakeVoiceMediaChannel::VoiceChannelAudioSink::OnClose() {
+void FakeVoiceMediaReceiveChannel::VoiceChannelAudioSink::OnClose() {
   source_ = nullptr;
 }
-AudioSource* FakeVoiceMediaChannel::VoiceChannelAudioSink::source() const {
+AudioSource* FakeVoiceMediaReceiveChannel::VoiceChannelAudioSink::source()
+    const {
   return source_;
 }
 
-FakeVoiceMediaChannel::FakeVoiceMediaChannel(MediaChannel::Role role,
-                                             FakeVoiceEngine* engine,
-                                             const AudioOptions& options,
-                                             TaskQueueBase* network_thread)
-    : RtpHelper<VoiceMediaChannel>(role, network_thread),
-      engine_(engine),
+FakeVoiceMediaReceiveChannel::FakeVoiceMediaReceiveChannel(
+    const AudioOptions& options,
+    TaskQueueBase* network_thread)
+    : RtpReceiveChannelHelper<VoiceMediaReceiveChannelInterface>(
+          network_thread),
       max_bps_(-1) {
   output_scalings_[0] = 1.0;  // For default channel.
   SetOptions(options);
 }
-FakeVoiceMediaChannel::~FakeVoiceMediaChannel() {
-  if (engine_) {
-    engine_->UnregisterChannel(this);
-  }
-}
-const std::vector<AudioCodec>& FakeVoiceMediaChannel::recv_codecs() const {
+FakeVoiceMediaReceiveChannel::~FakeVoiceMediaReceiveChannel() = default;
+const std::vector<AudioCodec>& FakeVoiceMediaReceiveChannel::recv_codecs()
+    const {
   return recv_codecs_;
 }
-const std::vector<AudioCodec>& FakeVoiceMediaChannel::send_codecs() const {
-  return send_codecs_;
-}
-const std::vector<AudioCodec>& FakeVoiceMediaChannel::codecs() const {
-  return send_codecs();
-}
-absl::optional<Codec> FakeVoiceMediaChannel::GetSendCodec() const {
-  if (!send_codecs_.empty()) {
-    return send_codecs_.front();
-  }
-  return absl::nullopt;
-}
-const std::vector<FakeVoiceMediaChannel::DtmfInfo>&
-FakeVoiceMediaChannel::dtmf_info_queue() const {
+const std::vector<FakeVoiceMediaReceiveChannel::DtmfInfo>&
+FakeVoiceMediaReceiveChannel::dtmf_info_queue() const {
   return dtmf_info_queue_;
 }
-const AudioOptions& FakeVoiceMediaChannel::options() const {
+const AudioOptions& FakeVoiceMediaReceiveChannel::options() const {
   return options_;
 }
-int FakeVoiceMediaChannel::max_bps() const {
+int FakeVoiceMediaReceiveChannel::max_bps() const {
   return max_bps_;
 }
-bool FakeVoiceMediaChannel::SetSendParameters(
-    const AudioSendParameters& params) {
-  set_send_rtcp_parameters(params.rtcp);
-  return (SetSendCodecs(params.codecs) &&
-          SetSendExtmapAllowMixed(params.extmap_allow_mixed) &&
-          SetSendRtpHeaderExtensions(params.extensions) &&
-          SetMaxSendBandwidth(params.max_bandwidth_bps) &&
-          SetOptions(params.options));
-}
-bool FakeVoiceMediaChannel::SetRecvParameters(
+bool FakeVoiceMediaReceiveChannel::SetRecvParameters(
     const AudioRecvParameters& params) {
   set_recv_rtcp_parameters(params.rtcp);
   return (SetRecvCodecs(params.codecs) &&
           SetRecvRtpHeaderExtensions(params.extensions));
 }
-void FakeVoiceMediaChannel::SetPlayout(bool playout) {
+void FakeVoiceMediaReceiveChannel::SetPlayout(bool playout) {
   set_playout(playout);
 }
-void FakeVoiceMediaChannel::SetSend(bool send) {
+bool FakeVoiceMediaReceiveChannel::HasSource(uint32_t ssrc) const {
+  return local_sinks_.find(ssrc) != local_sinks_.end();
+}
+bool FakeVoiceMediaReceiveChannel::AddRecvStream(const StreamParams& sp) {
+  if (!RtpReceiveChannelHelper<
+          VoiceMediaReceiveChannelInterface>::AddRecvStream(sp))
+    return false;
+  output_scalings_[sp.first_ssrc()] = 1.0;
+  output_delays_[sp.first_ssrc()] = 0;
+  return true;
+}
+bool FakeVoiceMediaReceiveChannel::RemoveRecvStream(uint32_t ssrc) {
+  if (!RtpReceiveChannelHelper<
+          VoiceMediaReceiveChannelInterface>::RemoveRecvStream(ssrc))
+    return false;
+  output_scalings_.erase(ssrc);
+  output_delays_.erase(ssrc);
+  return true;
+}
+bool FakeVoiceMediaReceiveChannel::SetOutputVolume(uint32_t ssrc,
+                                                   double volume) {
+  if (output_scalings_.find(ssrc) != output_scalings_.end()) {
+    output_scalings_[ssrc] = volume;
+    return true;
+  }
+  return false;
+}
+bool FakeVoiceMediaReceiveChannel::SetDefaultOutputVolume(double volume) {
+  for (auto& entry : output_scalings_) {
+    entry.second = volume;
+  }
+  return true;
+}
+bool FakeVoiceMediaReceiveChannel::GetOutputVolume(uint32_t ssrc,
+                                                   double* volume) {
+  if (output_scalings_.find(ssrc) == output_scalings_.end())
+    return false;
+  *volume = output_scalings_[ssrc];
+  return true;
+}
+bool FakeVoiceMediaReceiveChannel::SetBaseMinimumPlayoutDelayMs(uint32_t ssrc,
+                                                                int delay_ms) {
+  if (output_delays_.find(ssrc) == output_delays_.end()) {
+    return false;
+  } else {
+    output_delays_[ssrc] = delay_ms;
+    return true;
+  }
+}
+absl::optional<int> FakeVoiceMediaReceiveChannel::GetBaseMinimumPlayoutDelayMs(
+    uint32_t ssrc) const {
+  const auto it = output_delays_.find(ssrc);
+  if (it != output_delays_.end()) {
+    return it->second;
+  }
+  return absl::nullopt;
+}
+bool FakeVoiceMediaReceiveChannel::GetStats(VoiceMediaReceiveInfo* info,
+                                            bool get_and_clear_legacy_stats) {
+  return false;
+}
+void FakeVoiceMediaReceiveChannel::SetRawAudioSink(
+    uint32_t ssrc,
+    std::unique_ptr<webrtc::AudioSinkInterface> sink) {
+  sink_ = std::move(sink);
+}
+void FakeVoiceMediaReceiveChannel::SetDefaultRawAudioSink(
+    std::unique_ptr<webrtc::AudioSinkInterface> sink) {
+  sink_ = std::move(sink);
+}
+std::vector<webrtc::RtpSource> FakeVoiceMediaReceiveChannel::GetSources(
+    uint32_t ssrc) const {
+  return std::vector<webrtc::RtpSource>();
+}
+bool FakeVoiceMediaReceiveChannel::SetRecvCodecs(
+    const std::vector<AudioCodec>& codecs) {
+  if (fail_set_recv_codecs()) {
+    // Fake the failure in SetRecvCodecs.
+    return false;
+  }
+  recv_codecs_ = codecs;
+  return true;
+}
+bool FakeVoiceMediaReceiveChannel::SetMaxSendBandwidth(int bps) {
+  max_bps_ = bps;
+  return true;
+}
+bool FakeVoiceMediaReceiveChannel::SetOptions(const AudioOptions& options) {
+  // Does a "merge" of current options and set options.
+  options_.SetAll(options);
+  return true;
+}
+
+FakeVoiceMediaSendChannel::DtmfInfo::DtmfInfo(uint32_t ssrc,
+                                              int event_code,
+                                              int duration)
+    : ssrc(ssrc), event_code(event_code), duration(duration) {}
+
+FakeVoiceMediaSendChannel::VoiceChannelAudioSink::VoiceChannelAudioSink(
+    AudioSource* source)
+    : source_(source) {
+  source_->SetSink(this);
+}
+FakeVoiceMediaSendChannel::VoiceChannelAudioSink::~VoiceChannelAudioSink() {
+  if (source_) {
+    source_->SetSink(nullptr);
+  }
+}
+void FakeVoiceMediaSendChannel::VoiceChannelAudioSink::OnData(
+    const void* audio_data,
+    int bits_per_sample,
+    int sample_rate,
+    size_t number_of_channels,
+    size_t number_of_frames,
+    absl::optional<int64_t> absolute_capture_timestamp_ms) {}
+void FakeVoiceMediaSendChannel::VoiceChannelAudioSink::OnClose() {
+  source_ = nullptr;
+}
+AudioSource* FakeVoiceMediaSendChannel::VoiceChannelAudioSink::source() const {
+  return source_;
+}
+
+FakeVoiceMediaSendChannel::FakeVoiceMediaSendChannel(
+    const AudioOptions& options,
+    TaskQueueBase* network_thread)
+    : RtpSendChannelHelper<VoiceMediaSendChannelInterface>(network_thread),
+      max_bps_(-1) {
+  output_scalings_[0] = 1.0;  // For default channel.
+  SetOptions(options);
+}
+FakeVoiceMediaSendChannel::~FakeVoiceMediaSendChannel() = default;
+const std::vector<AudioCodec>& FakeVoiceMediaSendChannel::send_codecs() const {
+  return send_codecs_;
+}
+absl::optional<Codec> FakeVoiceMediaSendChannel::GetSendCodec() const {
+  if (!send_codecs_.empty()) {
+    return send_codecs_.front();
+  }
+  return absl::nullopt;
+}
+const std::vector<FakeVoiceMediaSendChannel::DtmfInfo>&
+FakeVoiceMediaSendChannel::dtmf_info_queue() const {
+  return dtmf_info_queue_;
+}
+const AudioOptions& FakeVoiceMediaSendChannel::options() const {
+  return options_;
+}
+int FakeVoiceMediaSendChannel::max_bps() const {
+  return max_bps_;
+}
+bool FakeVoiceMediaSendChannel::SetSendParameters(
+    const AudioSendParameters& params) {
+  set_send_rtcp_parameters(params.rtcp);
+  SetExtmapAllowMixed(params.extmap_allow_mixed);
+  return (SetSendCodecs(params.codecs) &&
+          SetSendRtpHeaderExtensions(params.extensions) &&
+          SetMaxSendBandwidth(params.max_bandwidth_bps) &&
+          SetOptions(params.options));
+}
+void FakeVoiceMediaSendChannel::SetSend(bool send) {
   set_sending(send);
 }
-bool FakeVoiceMediaChannel::SetAudioSend(uint32_t ssrc,
-                                         bool enable,
-                                         const AudioOptions* options,
-                                         AudioSource* source) {
+bool FakeVoiceMediaSendChannel::SetAudioSend(uint32_t ssrc,
+                                             bool enable,
+                                             const AudioOptions* options,
+                                             AudioSource* source) {
   if (!SetLocalSource(ssrc, source)) {
     return false;
   }
-  if (!RtpHelper<VoiceMediaChannel>::MuteStream(ssrc, !enable)) {
+  if (!RtpSendChannelHelper<VoiceMediaSendChannelInterface>::MuteStream(
+          ssrc, !enable)) {
     return false;
   }
   if (enable && options) {
@@ -126,24 +263,10 @@ bool FakeVoiceMediaChannel::SetAudioSend(uint32_t ssrc,
   }
   return true;
 }
-bool FakeVoiceMediaChannel::HasSource(uint32_t ssrc) const {
+bool FakeVoiceMediaSendChannel::HasSource(uint32_t ssrc) const {
   return local_sinks_.find(ssrc) != local_sinks_.end();
 }
-bool FakeVoiceMediaChannel::AddRecvStream(const StreamParams& sp) {
-  if (!RtpHelper<VoiceMediaChannel>::AddRecvStream(sp))
-    return false;
-  output_scalings_[sp.first_ssrc()] = 1.0;
-  output_delays_[sp.first_ssrc()] = 0;
-  return true;
-}
-bool FakeVoiceMediaChannel::RemoveRecvStream(uint32_t ssrc) {
-  if (!RtpHelper<VoiceMediaChannel>::RemoveRecvStream(ssrc))
-    return false;
-  output_scalings_.erase(ssrc);
-  output_delays_.erase(ssrc);
-  return true;
-}
-bool FakeVoiceMediaChannel::CanInsertDtmf() {
+bool FakeVoiceMediaSendChannel::CanInsertDtmf() {
   for (std::vector<AudioCodec>::const_iterator it = send_codecs_.begin();
        it != send_codecs_.end(); ++it) {
     // Find the DTMF telephone event "codec".
@@ -153,78 +276,22 @@ bool FakeVoiceMediaChannel::CanInsertDtmf() {
   }
   return false;
 }
-bool FakeVoiceMediaChannel::InsertDtmf(uint32_t ssrc,
-                                       int event_code,
-                                       int duration) {
+bool FakeVoiceMediaSendChannel::InsertDtmf(uint32_t ssrc,
+                                           int event_code,
+                                           int duration) {
   dtmf_info_queue_.push_back(DtmfInfo(ssrc, event_code, duration));
   return true;
 }
-bool FakeVoiceMediaChannel::SetOutputVolume(uint32_t ssrc, double volume) {
-  if (output_scalings_.find(ssrc) != output_scalings_.end()) {
-    output_scalings_[ssrc] = volume;
-    return true;
-  }
-  return false;
-}
-bool FakeVoiceMediaChannel::SetDefaultOutputVolume(double volume) {
-  for (auto& entry : output_scalings_) {
-    entry.second = volume;
-  }
-  return true;
-}
-bool FakeVoiceMediaChannel::GetOutputVolume(uint32_t ssrc, double* volume) {
+bool FakeVoiceMediaSendChannel::GetOutputVolume(uint32_t ssrc, double* volume) {
   if (output_scalings_.find(ssrc) == output_scalings_.end())
     return false;
   *volume = output_scalings_[ssrc];
   return true;
 }
-bool FakeVoiceMediaChannel::SetBaseMinimumPlayoutDelayMs(uint32_t ssrc,
-                                                         int delay_ms) {
-  if (output_delays_.find(ssrc) == output_delays_.end()) {
-    return false;
-  } else {
-    output_delays_[ssrc] = delay_ms;
-    return true;
-  }
-}
-absl::optional<int> FakeVoiceMediaChannel::GetBaseMinimumPlayoutDelayMs(
-    uint32_t ssrc) const {
-  const auto it = output_delays_.find(ssrc);
-  if (it != output_delays_.end()) {
-    return it->second;
-  }
-  return absl::nullopt;
-}
-bool FakeVoiceMediaChannel::GetSendStats(VoiceMediaSendInfo* info) {
+bool FakeVoiceMediaSendChannel::GetStats(VoiceMediaSendInfo* info) {
   return false;
 }
-bool FakeVoiceMediaChannel::GetReceiveStats(VoiceMediaReceiveInfo* info,
-                                            bool get_and_clear_legacy_stats) {
-  return false;
-}
-void FakeVoiceMediaChannel::SetRawAudioSink(
-    uint32_t ssrc,
-    std::unique_ptr<webrtc::AudioSinkInterface> sink) {
-  sink_ = std::move(sink);
-}
-void FakeVoiceMediaChannel::SetDefaultRawAudioSink(
-    std::unique_ptr<webrtc::AudioSinkInterface> sink) {
-  sink_ = std::move(sink);
-}
-std::vector<webrtc::RtpSource> FakeVoiceMediaChannel::GetSources(
-    uint32_t ssrc) const {
-  return std::vector<webrtc::RtpSource>();
-}
-bool FakeVoiceMediaChannel::SetRecvCodecs(
-    const std::vector<AudioCodec>& codecs) {
-  if (fail_set_recv_codecs()) {
-    // Fake the failure in SetRecvCodecs.
-    return false;
-  }
-  recv_codecs_ = codecs;
-  return true;
-}
-bool FakeVoiceMediaChannel::SetSendCodecs(
+bool FakeVoiceMediaSendChannel::SetSendCodecs(
     const std::vector<AudioCodec>& codecs) {
   if (fail_set_send_codecs()) {
     // Fake the failure in SetSendCodecs.
@@ -233,16 +300,17 @@ bool FakeVoiceMediaChannel::SetSendCodecs(
   send_codecs_ = codecs;
   return true;
 }
-bool FakeVoiceMediaChannel::SetMaxSendBandwidth(int bps) {
+bool FakeVoiceMediaSendChannel::SetMaxSendBandwidth(int bps) {
   max_bps_ = bps;
   return true;
 }
-bool FakeVoiceMediaChannel::SetOptions(const AudioOptions& options) {
+bool FakeVoiceMediaSendChannel::SetOptions(const AudioOptions& options) {
   // Does a "merge" of current options and set options.
   options_.SetAll(options);
   return true;
 }
-bool FakeVoiceMediaChannel::SetLocalSource(uint32_t ssrc, AudioSource* source) {
+bool FakeVoiceMediaSendChannel::SetLocalSource(uint32_t ssrc,
+                                               AudioSource* source) {
   auto it = local_sinks_.find(ssrc);
   if (source) {
     if (it != local_sinks_.end()) {
@@ -259,7 +327,7 @@ bool FakeVoiceMediaChannel::SetLocalSource(uint32_t ssrc, AudioSource* source) {
   return true;
 }
 
-bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info,
+bool CompareDtmfInfo(const FakeVoiceMediaSendChannel::DtmfInfo& info,
                      uint32_t ssrc,
                      int event_code,
                      int duration) {
@@ -267,87 +335,44 @@ bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info,
           info.ssrc == ssrc);
 }
 
-FakeVideoMediaChannel::FakeVideoMediaChannel(MediaChannel::Role role,
-                                             FakeVideoEngine* engine,
-                                             const VideoOptions& options,
-                                             TaskQueueBase* network_thread)
-    : RtpHelper<VideoMediaChannel>(role, network_thread),
-      engine_(engine),
+FakeVideoMediaSendChannel::FakeVideoMediaSendChannel(
+    const VideoOptions& options,
+    TaskQueueBase* network_thread)
+    : RtpSendChannelHelper<VideoMediaSendChannelInterface>(network_thread),
       max_bps_(-1) {
   SetOptions(options);
 }
-FakeVideoMediaChannel::~FakeVideoMediaChannel() {
-  if (engine_) {
-    engine_->UnregisterChannel(this);
-  }
-}
-const std::vector<VideoCodec>& FakeVideoMediaChannel::recv_codecs() const {
-  return recv_codecs_;
-}
-const std::vector<VideoCodec>& FakeVideoMediaChannel::send_codecs() const {
+FakeVideoMediaSendChannel::~FakeVideoMediaSendChannel() = default;
+const std::vector<VideoCodec>& FakeVideoMediaSendChannel::send_codecs() const {
   return send_codecs_;
 }
-const std::vector<VideoCodec>& FakeVideoMediaChannel::codecs() const {
+const std::vector<VideoCodec>& FakeVideoMediaSendChannel::codecs() const {
   return send_codecs();
 }
-bool FakeVideoMediaChannel::rendering() const {
-  return playout();
-}
-const VideoOptions& FakeVideoMediaChannel::options() const {
+const VideoOptions& FakeVideoMediaSendChannel::options() const {
   return options_;
 }
-const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
-FakeVideoMediaChannel::sinks() const {
-  return sinks_;
-}
-int FakeVideoMediaChannel::max_bps() const {
+int FakeVideoMediaSendChannel::max_bps() const {
   return max_bps_;
 }
-bool FakeVideoMediaChannel::SetSendParameters(
+bool FakeVideoMediaSendChannel::SetSendParameters(
     const VideoSendParameters& params) {
   set_send_rtcp_parameters(params.rtcp);
+  SetExtmapAllowMixed(params.extmap_allow_mixed);
   return (SetSendCodecs(params.codecs) &&
-          SetSendExtmapAllowMixed(params.extmap_allow_mixed) &&
           SetSendRtpHeaderExtensions(params.extensions) &&
           SetMaxSendBandwidth(params.max_bandwidth_bps));
 }
-bool FakeVideoMediaChannel::SetRecvParameters(
-    const VideoRecvParameters& params) {
-  set_recv_rtcp_parameters(params.rtcp);
-  return (SetRecvCodecs(params.codecs) &&
-          SetRecvRtpHeaderExtensions(params.extensions));
-}
-bool FakeVideoMediaChannel::AddSendStream(const StreamParams& sp) {
-  return RtpHelper<VideoMediaChannel>::AddSendStream(sp);
-}
-bool FakeVideoMediaChannel::RemoveSendStream(uint32_t ssrc) {
-  return RtpHelper<VideoMediaChannel>::RemoveSendStream(ssrc);
-}
-absl::optional<Codec> FakeVideoMediaChannel::GetSendCodec() const {
+absl::optional<Codec> FakeVideoMediaSendChannel::GetSendCodec() const {
   if (send_codecs_.empty()) {
     return absl::nullopt;
   }
   return send_codecs_[0];
 }
-bool FakeVideoMediaChannel::SetSink(
-    uint32_t ssrc,
-    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
-  auto it = sinks_.find(ssrc);
-  if (it == sinks_.end()) {
-    return false;
-  }
-  it->second = sink;
-  return true;
-}
-void FakeVideoMediaChannel::SetDefaultSink(
-    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {}
-bool FakeVideoMediaChannel::HasSink(uint32_t ssrc) const {
-  return sinks_.find(ssrc) != sinks_.end() && sinks_.at(ssrc) != nullptr;
-}
-bool FakeVideoMediaChannel::SetSend(bool send) {
+bool FakeVideoMediaSendChannel::SetSend(bool send) {
   return set_sending(send);
 }
-bool FakeVideoMediaChannel::SetVideoSend(
+bool FakeVideoMediaSendChannel::SetVideoSend(
     uint32_t ssrc,
     const VideoOptions* options,
     rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
@@ -359,62 +384,15 @@ bool FakeVideoMediaChannel::SetVideoSend(
   sources_[ssrc] = source;
   return true;
 }
-bool FakeVideoMediaChannel::HasSource(uint32_t ssrc) const {
+bool FakeVideoMediaSendChannel::HasSource(uint32_t ssrc) const {
   return sources_.find(ssrc) != sources_.end() && sources_.at(ssrc) != nullptr;
 }
-bool FakeVideoMediaChannel::AddRecvStream(const StreamParams& sp) {
-  if (!RtpHelper<VideoMediaChannel>::AddRecvStream(sp))
-    return false;
-  sinks_[sp.first_ssrc()] = NULL;
-  output_delays_[sp.first_ssrc()] = 0;
-  return true;
-}
-bool FakeVideoMediaChannel::RemoveRecvStream(uint32_t ssrc) {
-  if (!RtpHelper<VideoMediaChannel>::RemoveRecvStream(ssrc))
-    return false;
-  sinks_.erase(ssrc);
-  output_delays_.erase(ssrc);
-  return true;
-}
-void FakeVideoMediaChannel::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) {
-}
-bool FakeVideoMediaChannel::GetSendStats(VideoMediaSendInfo* info) {
+void FakeVideoMediaSendChannel::FillBitrateInfo(
+    BandwidthEstimationInfo* bwe_info) {}
+bool FakeVideoMediaSendChannel::GetStats(VideoMediaSendInfo* info) {
   return false;
 }
-bool FakeVideoMediaChannel::GetReceiveStats(VideoMediaReceiveInfo* info) {
-  return false;
-}
-std::vector<webrtc::RtpSource> FakeVideoMediaChannel::GetSources(
-    uint32_t ssrc) const {
-  return {};
-}
-bool FakeVideoMediaChannel::SetBaseMinimumPlayoutDelayMs(uint32_t ssrc,
-                                                         int delay_ms) {
-  if (output_delays_.find(ssrc) == output_delays_.end()) {
-    return false;
-  } else {
-    output_delays_[ssrc] = delay_ms;
-    return true;
-  }
-}
-absl::optional<int> FakeVideoMediaChannel::GetBaseMinimumPlayoutDelayMs(
-    uint32_t ssrc) const {
-  const auto it = output_delays_.find(ssrc);
-  if (it != output_delays_.end()) {
-    return it->second;
-  }
-  return absl::nullopt;
-}
-bool FakeVideoMediaChannel::SetRecvCodecs(
-    const std::vector<VideoCodec>& codecs) {
-  if (fail_set_recv_codecs()) {
-    // Fake the failure in SetRecvCodecs.
-    return false;
-  }
-  recv_codecs_ = codecs;
-  return true;
-}
-bool FakeVideoMediaChannel::SetSendCodecs(
+bool FakeVideoMediaSendChannel::SetSendCodecs(
     const std::vector<VideoCodec>& codecs) {
   if (fail_set_send_codecs()) {
     // Fake the failure in SetSendCodecs.
@@ -424,27 +402,137 @@ bool FakeVideoMediaChannel::SetSendCodecs(
 
   return true;
 }
-bool FakeVideoMediaChannel::SetOptions(const VideoOptions& options) {
+bool FakeVideoMediaSendChannel::SetOptions(const VideoOptions& options) {
   options_ = options;
   return true;
 }
 
-bool FakeVideoMediaChannel::SetMaxSendBandwidth(int bps) {
+bool FakeVideoMediaSendChannel::SetMaxSendBandwidth(int bps) {
+  max_bps_ = bps;
+  return true;
+}
+void FakeVideoMediaSendChannel::GenerateSendKeyFrame(
+    uint32_t ssrc,
+    const std::vector<std::string>& rids) {}
+
+FakeVideoMediaReceiveChannel::FakeVideoMediaReceiveChannel(
+    const VideoOptions& options,
+    TaskQueueBase* network_thread)
+    : RtpReceiveChannelHelper<VideoMediaReceiveChannelInterface>(
+          network_thread),
+      max_bps_(-1) {
+  SetOptions(options);
+}
+FakeVideoMediaReceiveChannel::~FakeVideoMediaReceiveChannel() = default;
+const std::vector<VideoCodec>& FakeVideoMediaReceiveChannel::recv_codecs()
+    const {
+  return recv_codecs_;
+}
+bool FakeVideoMediaReceiveChannel::rendering() const {
+  return playout();
+}
+const VideoOptions& FakeVideoMediaReceiveChannel::options() const {
+  return options_;
+}
+const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
+FakeVideoMediaReceiveChannel::sinks() const {
+  return sinks_;
+}
+int FakeVideoMediaReceiveChannel::max_bps() const {
+  return max_bps_;
+}
+bool FakeVideoMediaReceiveChannel::SetRecvParameters(
+    const VideoRecvParameters& params) {
+  set_recv_rtcp_parameters(params.rtcp);
+  return (SetRecvCodecs(params.codecs) &&
+          SetRecvRtpHeaderExtensions(params.extensions));
+}
+bool FakeVideoMediaReceiveChannel::SetSink(
+    uint32_t ssrc,
+    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
+  auto it = sinks_.find(ssrc);
+  if (it == sinks_.end()) {
+    return false;
+  }
+  it->second = sink;
+  return true;
+}
+void FakeVideoMediaReceiveChannel::SetDefaultSink(
+    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {}
+bool FakeVideoMediaReceiveChannel::HasSink(uint32_t ssrc) const {
+  return sinks_.find(ssrc) != sinks_.end() && sinks_.at(ssrc) != nullptr;
+}
+bool FakeVideoMediaReceiveChannel::HasSource(uint32_t ssrc) const {
+  return sources_.find(ssrc) != sources_.end() && sources_.at(ssrc) != nullptr;
+}
+bool FakeVideoMediaReceiveChannel::AddRecvStream(const StreamParams& sp) {
+  if (!RtpReceiveChannelHelper<
+          VideoMediaReceiveChannelInterface>::AddRecvStream(sp))
+    return false;
+  sinks_[sp.first_ssrc()] = NULL;
+  output_delays_[sp.first_ssrc()] = 0;
+  return true;
+}
+bool FakeVideoMediaReceiveChannel::RemoveRecvStream(uint32_t ssrc) {
+  if (!RtpReceiveChannelHelper<
+          VideoMediaReceiveChannelInterface>::RemoveRecvStream(ssrc))
+    return false;
+  sinks_.erase(ssrc);
+  output_delays_.erase(ssrc);
+  return true;
+}
+std::vector<webrtc::RtpSource> FakeVideoMediaReceiveChannel::GetSources(
+    uint32_t ssrc) const {
+  return {};
+}
+bool FakeVideoMediaReceiveChannel::SetBaseMinimumPlayoutDelayMs(uint32_t ssrc,
+                                                                int delay_ms) {
+  if (output_delays_.find(ssrc) == output_delays_.end()) {
+    return false;
+  } else {
+    output_delays_[ssrc] = delay_ms;
+    return true;
+  }
+}
+absl::optional<int> FakeVideoMediaReceiveChannel::GetBaseMinimumPlayoutDelayMs(
+    uint32_t ssrc) const {
+  const auto it = output_delays_.find(ssrc);
+  if (it != output_delays_.end()) {
+    return it->second;
+  }
+  return absl::nullopt;
+}
+bool FakeVideoMediaReceiveChannel::SetRecvCodecs(
+    const std::vector<VideoCodec>& codecs) {
+  if (fail_set_recv_codecs()) {
+    // Fake the failure in SetRecvCodecs.
+    return false;
+  }
+  recv_codecs_ = codecs;
+  return true;
+}
+bool FakeVideoMediaReceiveChannel::SetOptions(const VideoOptions& options) {
+  options_ = options;
+  return true;
+}
+
+bool FakeVideoMediaReceiveChannel::SetMaxSendBandwidth(int bps) {
   max_bps_ = bps;
   return true;
 }
 
-void FakeVideoMediaChannel::SetRecordableEncodedFrameCallback(
+void FakeVideoMediaReceiveChannel::SetRecordableEncodedFrameCallback(
     uint32_t ssrc,
     std::function<void(const webrtc::RecordableEncodedFrame&)> callback) {}
 
-void FakeVideoMediaChannel::ClearRecordableEncodedFrameCallback(uint32_t ssrc) {
-}
+void FakeVideoMediaReceiveChannel::ClearRecordableEncodedFrameCallback(
+    uint32_t ssrc) {}
 
-void FakeVideoMediaChannel::RequestRecvKeyFrame(uint32_t ssrc) {}
-void FakeVideoMediaChannel::GenerateSendKeyFrame(
-    uint32_t ssrc,
-    const std::vector<std::string>& rids) {}
+void FakeVideoMediaReceiveChannel::RequestRecvKeyFrame(uint32_t ssrc) {}
+
+bool FakeVideoMediaReceiveChannel::GetStats(VideoMediaReceiveInfo* info) {
+  return false;
+}
 
 FakeVoiceEngine::FakeVoiceEngine() : fail_create_channel_(false) {
   // Add a fake audio codec. Note that the name must not be "" as there are
@@ -455,57 +543,29 @@ void FakeVoiceEngine::Init() {}
 rtc::scoped_refptr<webrtc::AudioState> FakeVoiceEngine::GetAudioState() const {
   return rtc::scoped_refptr<webrtc::AudioState>();
 }
-VoiceMediaChannel* FakeVoiceEngine::CreateMediaChannel(
-    MediaChannel::Role role,
+std::unique_ptr<VoiceMediaSendChannelInterface>
+FakeVoiceEngine::CreateSendChannel(webrtc::Call* call,
+                                   const MediaConfig& config,
+                                   const AudioOptions& options,
+                                   const webrtc::CryptoOptions& crypto_options,
+                                   webrtc::AudioCodecPairId codec_pair_id) {
+  std::unique_ptr<FakeVoiceMediaSendChannel> ch =
+      std::make_unique<FakeVoiceMediaSendChannel>(options,
+                                                  call->network_thread());
+  return ch;
+}
+std::unique_ptr<VoiceMediaReceiveChannelInterface>
+FakeVoiceEngine::CreateReceiveChannel(
     webrtc::Call* call,
     const MediaConfig& config,
     const AudioOptions& options,
     const webrtc::CryptoOptions& crypto_options,
     webrtc::AudioCodecPairId codec_pair_id) {
-  if (fail_create_channel_) {
-    return nullptr;
-  }
-
-  FakeVoiceMediaChannel* ch =
-      new FakeVoiceMediaChannel(role, this, options, call->network_thread());
-  switch (role) {
-    case MediaChannel::Role::kSend:
-      send_channels_.push_back(ch);
-      break;
-    case MediaChannel::Role::kReceive:
-      receive_channels_.push_back(ch);
-      break;
-    case MediaChannel::Role::kBoth:
-      send_channels_.push_back(ch);
-      receive_channels_.push_back(ch);
-      break;
-    default:
-      RTC_CHECK_NOTREACHED();
-  }
+  std::unique_ptr<FakeVoiceMediaReceiveChannel> ch =
+      std::make_unique<FakeVoiceMediaReceiveChannel>(options,
+                                                     call->network_thread());
   return ch;
 }
-FakeVoiceMediaChannel* FakeVoiceEngine::GetSendChannel(size_t index) {
-  return (send_channels_.size() > index) ? send_channels_[index] : NULL;
-}
-FakeVoiceMediaChannel* FakeVoiceEngine::GetReceiveChannel(size_t index) {
-  return (receive_channels_.size() > index) ? receive_channels_[index] : NULL;
-}
-void FakeVoiceEngine::UnregisterChannel(VoiceMediaChannel* channel) {
-  switch (channel->role()) {
-    case MediaChannel::Role::kSend:
-      send_channels_.erase(absl::c_find(send_channels_, channel));
-      break;
-    case MediaChannel::Role::kReceive:
-      receive_channels_.erase(absl::c_find(receive_channels_, channel));
-      break;
-    case MediaChannel::Role::kBoth:
-      send_channels_.erase(absl::c_find(send_channels_, channel));
-      receive_channels_.erase(absl::c_find(receive_channels_, channel));
-      break;
-    default:
-      RTC_CHECK_NOTREACHED();
-  }
-}
 const std::vector<AudioCodec>& FakeVoiceEngine::send_codecs() const {
   return send_codecs_;
 }
@@ -556,8 +616,8 @@ bool FakeVideoEngine::SetOptions(const VideoOptions& options) {
   options_ = options;
   return true;
 }
-VideoMediaChannel* FakeVideoEngine::CreateMediaChannel(
-    MediaChannel::Role role,
+std::unique_ptr<VideoMediaSendChannelInterface>
+FakeVideoEngine::CreateSendChannel(
     webrtc::Call* call,
     const MediaConfig& config,
     const VideoOptions& options,
@@ -567,54 +627,25 @@ VideoMediaChannel* FakeVideoEngine::CreateMediaChannel(
     return nullptr;
   }
 
-  FakeVideoMediaChannel* ch =
-      new FakeVideoMediaChannel(role, this, options, call->network_thread());
-  switch (role) {
-    case MediaChannel::Role::kSend:
-      send_channels_.emplace_back(ch);
-      break;
-    case MediaChannel::Role::kReceive:
-      receive_channels_.emplace_back(ch);
-      break;
-    case MediaChannel::Role::kBoth:
-      send_channels_.push_back(ch);
-      receive_channels_.push_back(ch);
-      break;
-    default:
-      RTC_CHECK_NOTREACHED();
-  }
+  std::unique_ptr<FakeVideoMediaSendChannel> ch =
+      std::make_unique<FakeVideoMediaSendChannel>(options,
+                                                  call->network_thread());
   return ch;
 }
-FakeVideoMediaChannel* FakeVideoEngine::GetSendChannel(size_t index) {
-  return (send_channels_.size() > index) ? send_channels_[index] : nullptr;
-}
-FakeVideoMediaChannel* FakeVideoEngine::GetReceiveChannel(size_t index) {
-  return (receive_channels_.size() > index) ? receive_channels_[index]
-                                            : nullptr;
-}
-void FakeVideoEngine::UnregisterChannel(VideoMediaChannel* channel) {
-  switch (channel->role()) {
-    case MediaChannel::Role::kSend: {
-      auto it = absl::c_find(send_channels_, channel);
-      RTC_DCHECK(it != send_channels_.end());
-      send_channels_.erase(it);
-    } break;
-    case MediaChannel::Role::kReceive: {
-      auto it = absl::c_find(receive_channels_, channel);
-      RTC_DCHECK(it != receive_channels_.end());
-      receive_channels_.erase(it);
-    } break;
-    case MediaChannel::Role::kBoth: {
-      auto it = absl::c_find(send_channels_, channel);
-      RTC_DCHECK(it != send_channels_.end());
-      send_channels_.erase(it);
-      it = absl::c_find(receive_channels_, channel);
-      RTC_DCHECK(it != receive_channels_.end());
-      receive_channels_.erase(it);
-    } break;
-    default:
-      RTC_CHECK_NOTREACHED();
+std::unique_ptr<VideoMediaReceiveChannelInterface>
+FakeVideoEngine::CreateReceiveChannel(
+    webrtc::Call* call,
+    const MediaConfig& config,
+    const VideoOptions& options,
+    const webrtc::CryptoOptions& crypto_options) {
+  if (fail_create_channel_) {
+    return nullptr;
   }
+
+  std::unique_ptr<FakeVideoMediaReceiveChannel> ch =
+      std::make_unique<FakeVideoMediaReceiveChannel>(options,
+                                                     call->network_thread());
+  return ch;
 }
 std::vector<VideoCodec> FakeVideoEngine::send_codecs(bool use_rtx) const {
   return send_codecs_;
@@ -666,20 +697,6 @@ void FakeMediaEngine::SetVideoCodecs(const std::vector<VideoCodec>& codecs) {
   video_->SetSendCodecs(codecs);
   video_->SetRecvCodecs(codecs);
 }
-
-FakeVoiceMediaChannel* FakeMediaEngine::GetVoiceSendChannel(size_t index) {
-  return voice_->GetSendChannel(index);
-}
-FakeVideoMediaChannel* FakeMediaEngine::GetVideoSendChannel(size_t index) {
-  return video_->GetSendChannel(index);
-}
-FakeVoiceMediaChannel* FakeMediaEngine::GetVoiceReceiveChannel(size_t index) {
-  return voice_->GetReceiveChannel(index);
-}
-FakeVideoMediaChannel* FakeMediaEngine::GetVideoReceiveChannel(size_t index) {
-  return video_->GetReceiveChannel(index);
-}
-
 void FakeMediaEngine::set_fail_create_channel(bool fail) {
   voice_->fail_create_channel_ = fail;
   video_->fail_create_channel_ = fail;
diff --git a/media/base/fake_media_engine.h b/media/base/fake_media_engine.h
index caa5fab4be..34c91cf08f 100644
--- a/media/base/fake_media_engine.h
+++ b/media/base/fake_media_engine.h
@@ -18,11 +18,16 @@
 #include <set>
 #include <string>
 #include <tuple>
+#include <utility>
 #include <vector>
 
 #include "absl/algorithm/container.h"
+#include "absl/functional/any_invocable.h"
 #include "api/call/audio_sink.h"
+#include "api/media_types.h"
 #include "media/base/audio_source.h"
+#include "media/base/media_channel.h"
+#include "media/base/media_channel_impl.h"
 #include "media/base/media_engine.h"
 #include "media/base/rtp_utils.h"
 #include "media/base/stream_params.h"
@@ -43,41 +48,22 @@ class FakeVoiceEngine;
 
 // A common helper class that handles sending and receiving RTP/RTCP packets.
 template <class Base>
-class RtpHelper : public Base {
+class RtpReceiveChannelHelper : public Base, public MediaChannelUtil {
  public:
-  explicit RtpHelper(MediaChannel::Role role,
-                     webrtc::TaskQueueBase* network_thread)
-      : Base(role, network_thread),
-        sending_(false),
+  explicit RtpReceiveChannelHelper(webrtc::TaskQueueBase* network_thread)
+      : MediaChannelUtil(network_thread),
         playout_(false),
-        fail_set_send_codecs_(false),
         fail_set_recv_codecs_(false),
-        send_ssrc_(0),
-        ready_to_send_(false),
         transport_overhead_per_packet_(0),
         num_network_route_changes_(0) {}
-  virtual ~RtpHelper() = default;
+  virtual ~RtpReceiveChannelHelper() = default;
   const std::vector<RtpExtension>& recv_extensions() {
     return recv_extensions_;
   }
-  const std::vector<RtpExtension>& send_extensions() {
-    return send_extensions_;
-  }
-  bool sending() const { return sending_; }
   bool playout() const { return playout_; }
   const std::list<std::string>& rtp_packets() const { return rtp_packets_; }
   const std::list<std::string>& rtcp_packets() const { return rtcp_packets_; }
 
-  bool SendRtp(const void* data,
-               size_t len,
-               const rtc::PacketOptions& options) {
-    if (!sending_) {
-      return false;
-    }
-    rtc::CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len,
-                                  kMaxRtpPacketLen);
-    return Base::SendPacket(&packet, options);
-  }
   bool SendRtcp(const void* data, size_t len) {
     rtc::CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len,
                                   kMaxRtpPacketLen);
@@ -104,37 +90,18 @@ class RtpHelper : public Base {
   }
   bool CheckNoRtp() { return rtp_packets_.empty(); }
   bool CheckNoRtcp() { return rtcp_packets_.empty(); }
-  void set_fail_set_send_codecs(bool fail) { fail_set_send_codecs_ = fail; }
   void set_fail_set_recv_codecs(bool fail) { fail_set_recv_codecs_ = fail; }
-  virtual bool AddSendStream(const StreamParams& sp) {
-    if (absl::c_linear_search(send_streams_, sp)) {
-      return false;
-    }
-    send_streams_.push_back(sp);
-    rtp_send_parameters_[sp.first_ssrc()] =
-        CreateRtpParametersWithEncodings(sp);
-    return true;
-  }
-  virtual bool RemoveSendStream(uint32_t ssrc) {
-    auto parameters_iterator = rtp_send_parameters_.find(ssrc);
-    if (parameters_iterator != rtp_send_parameters_.end()) {
-      rtp_send_parameters_.erase(parameters_iterator);
-    }
-    return RemoveStreamBySsrc(&send_streams_, ssrc);
-  }
-  virtual void ResetUnsignaledRecvStream() {}
-  virtual absl::optional<uint32_t> GetUnsignaledSsrc() const {
+  void ResetUnsignaledRecvStream() override {}
+  absl::optional<uint32_t> GetUnsignaledSsrc() const override {
     return absl::nullopt;
   }
   void ChooseReceiverReportSsrc(const std::set<uint32_t>& choices) override {}
-  void SetSsrcListChangedCallback(
-      absl::AnyInvocable<void(const std::set<uint32_t>&)> callback) override {}
 
   virtual bool SetLocalSsrc(const StreamParams& sp) { return true; }
-  virtual void OnDemuxerCriteriaUpdatePending() {}
-  virtual void OnDemuxerCriteriaUpdateComplete() {}
+  void OnDemuxerCriteriaUpdatePending() override {}
+  void OnDemuxerCriteriaUpdateComplete() override {}
 
-  virtual bool AddRecvStream(const StreamParams& sp) {
+  bool AddRecvStream(const StreamParams& sp) override {
     if (absl::c_linear_search(receive_streams_, sp)) {
       return false;
     }
@@ -143,11 +110,7 @@ class RtpHelper : public Base {
         CreateRtpParametersWithEncodings(sp);
     return true;
   }
-  virtual bool AddDefaultRecvStreamForTesting(const StreamParams& sp) {
-    RTC_CHECK_NOTREACHED();
-    return false;
-  }
-  virtual bool RemoveRecvStream(uint32_t ssrc) {
+  bool RemoveRecvStream(uint32_t ssrc) override {
     auto parameters_iterator = rtp_receive_parameters_.find(ssrc);
     if (parameters_iterator != rtp_receive_parameters_.end()) {
       rtp_receive_parameters_.erase(parameters_iterator);
@@ -155,17 +118,191 @@ class RtpHelper : public Base {
     return RemoveStreamBySsrc(&receive_streams_, ssrc);
   }
 
-  virtual webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const {
+  webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override {
+    auto parameters_iterator = rtp_receive_parameters_.find(ssrc);
+    if (parameters_iterator != rtp_receive_parameters_.end()) {
+      return parameters_iterator->second;
+    }
+    return webrtc::RtpParameters();
+  }
+  webrtc::RtpParameters GetDefaultRtpReceiveParameters() const override {
+    return webrtc::RtpParameters();
+  }
+
+  const std::vector<StreamParams>& recv_streams() const {
+    return receive_streams_;
+  }
+  bool HasRecvStream(uint32_t ssrc) const {
+    return GetStreamBySsrc(receive_streams_, ssrc) != nullptr;
+  }
+
+  const RtcpParameters& recv_rtcp_parameters() { return recv_rtcp_parameters_; }
+
+  int transport_overhead_per_packet() const {
+    return transport_overhead_per_packet_;
+  }
+
+  rtc::NetworkRoute last_network_route() const { return last_network_route_; }
+  int num_network_route_changes() const { return num_network_route_changes_; }
+  void set_num_network_route_changes(int changes) {
+    num_network_route_changes_ = changes;
+  }
+
+  void OnRtcpPacketReceived(rtc::CopyOnWriteBuffer* packet,
+                            int64_t packet_time_us) {
+    rtcp_packets_.push_back(std::string(packet->cdata<char>(), packet->size()));
+  }
+
+  void SetFrameDecryptor(uint32_t ssrc,
+                         rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
+                             frame_decryptor) override {}
+
+  void SetDepacketizerToDecoderFrameTransformer(
+      uint32_t ssrc,
+      rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
+      override {}
+
+  void SetInterface(MediaChannelNetworkInterface* iface) override {
+    network_interface_ = iface;
+    MediaChannelUtil::SetInterface(iface);
+  }
+
+ protected:
+  void set_playout(bool playout) { playout_ = playout; }
+  bool SetRecvRtpHeaderExtensions(const std::vector<RtpExtension>& extensions) {
+    recv_extensions_ = extensions;
+    return true;
+  }
+  void set_recv_rtcp_parameters(const RtcpParameters& params) {
+    recv_rtcp_parameters_ = params;
+  }
+  void OnPacketReceived(const webrtc::RtpPacketReceived& packet) override {
+    rtp_packets_.push_back(
+        std::string(packet.Buffer().cdata<char>(), packet.size()));
+  }
+  bool fail_set_recv_codecs() const { return fail_set_recv_codecs_; }
+
+ private:
+  bool playout_;
+  std::vector<RtpExtension> recv_extensions_;
+  std::list<std::string> rtp_packets_;
+  std::list<std::string> rtcp_packets_;
+  std::vector<StreamParams> receive_streams_;
+  RtcpParameters recv_rtcp_parameters_;
+  std::map<uint32_t, webrtc::RtpParameters> rtp_receive_parameters_;
+  bool fail_set_recv_codecs_;
+  std::string rtcp_cname_;
+  int transport_overhead_per_packet_;
+  rtc::NetworkRoute last_network_route_;
+  int num_network_route_changes_;
+  MediaChannelNetworkInterface* network_interface_ = nullptr;
+};
+
+// A common helper class that handles sending and receiving RTP/RTCP packets.
+template <class Base>
+class RtpSendChannelHelper : public Base, public MediaChannelUtil {
+ public:
+  explicit RtpSendChannelHelper(webrtc::TaskQueueBase* network_thread)
+      : MediaChannelUtil(network_thread),
+        sending_(false),
+        fail_set_send_codecs_(false),
+        send_ssrc_(0),
+        ready_to_send_(false),
+        transport_overhead_per_packet_(0),
+        num_network_route_changes_(0) {}
+  virtual ~RtpSendChannelHelper() = default;
+  const std::vector<RtpExtension>& send_extensions() {
+    return send_extensions_;
+  }
+  bool sending() const { return sending_; }
+  const std::list<std::string>& rtp_packets() const { return rtp_packets_; }
+  const std::list<std::string>& rtcp_packets() const { return rtcp_packets_; }
+
+  bool SendPacket(const void* data,
+                  size_t len,
+                  const rtc::PacketOptions& options) {
+    if (!sending_) {
+      return false;
+    }
+    rtc::CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len,
+                                  kMaxRtpPacketLen);
+    return MediaChannelUtil::SendPacket(&packet, options);
+  }
+  bool SendRtcp(const void* data, size_t len) {
+    rtc::CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len,
+                                  kMaxRtpPacketLen);
+    return MediaChannelUtil::SendRtcp(&packet, rtc::PacketOptions());
+  }
+
+  bool CheckRtp(const void* data, size_t len) {
+    bool success = !rtp_packets_.empty();
+    if (success) {
+      std::string packet = rtp_packets_.front();
+      rtp_packets_.pop_front();
+      success = (packet == std::string(static_cast<const char*>(data), len));
+    }
+    return success;
+  }
+  bool CheckRtcp(const void* data, size_t len) {
+    bool success = !rtcp_packets_.empty();
+    if (success) {
+      std::string packet = rtcp_packets_.front();
+      rtcp_packets_.pop_front();
+      success = (packet == std::string(static_cast<const char*>(data), len));
+    }
+    return success;
+  }
+  bool CheckNoRtp() { return rtp_packets_.empty(); }
+  bool CheckNoRtcp() { return rtcp_packets_.empty(); }
+  void set_fail_set_send_codecs(bool fail) { fail_set_send_codecs_ = fail; }
+  bool AddSendStream(const StreamParams& sp) override {
+    if (absl::c_linear_search(send_streams_, sp)) {
+      return false;
+    }
+    send_streams_.push_back(sp);
+    rtp_send_parameters_[sp.first_ssrc()] =
+        CreateRtpParametersWithEncodings(sp);
+
+    if (ssrc_list_changed_callback_) {
+      std::set<uint32_t> ssrcs_in_use;
+      for (const auto& send_stream : send_streams_) {
+        ssrcs_in_use.insert(send_stream.first_ssrc());
+      }
+      ssrc_list_changed_callback_(ssrcs_in_use);
+    }
+
+    return true;
+  }
+  bool RemoveSendStream(uint32_t ssrc) override {
+    auto parameters_iterator = rtp_send_parameters_.find(ssrc);
+    if (parameters_iterator != rtp_send_parameters_.end()) {
+      rtp_send_parameters_.erase(parameters_iterator);
+    }
+    return RemoveStreamBySsrc(&send_streams_, ssrc);
+  }
+  void SetSsrcListChangedCallback(
+      absl::AnyInvocable<void(const std::set<uint32_t>&)> callback) override {
+    ssrc_list_changed_callback_ = std::move(callback);
+  }
+
+  void SetExtmapAllowMixed(bool extmap_allow_mixed) override {
+    return MediaChannelUtil::SetExtmapAllowMixed(extmap_allow_mixed);
+  }
+  bool ExtmapAllowMixed() const override {
+    return MediaChannelUtil::ExtmapAllowMixed();
+  }
+
+  webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const override {
     auto parameters_iterator = rtp_send_parameters_.find(ssrc);
     if (parameters_iterator != rtp_send_parameters_.end()) {
       return parameters_iterator->second;
     }
     return webrtc::RtpParameters();
   }
-  virtual webrtc::RTCError SetRtpSendParameters(
+  webrtc::RTCError SetRtpSendParameters(
       uint32_t ssrc,
       const webrtc::RtpParameters& parameters,
-      webrtc::SetParametersCallback callback) {
+      webrtc::SetParametersCallback callback) override {
     auto parameters_iterator = rtp_send_parameters_.find(ssrc);
     if (parameters_iterator != rtp_send_parameters_.end()) {
       auto result = CheckRtpParametersInvalidModificationAndValues(
@@ -185,17 +322,6 @@ class RtpHelper : public Base {
         callback, webrtc::RTCError(webrtc::RTCErrorType::INTERNAL_ERROR));
   }
 
-  virtual webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const {
-    auto parameters_iterator = rtp_receive_parameters_.find(ssrc);
-    if (parameters_iterator != rtp_receive_parameters_.end()) {
-      return parameters_iterator->second;
-    }
-    return webrtc::RtpParameters();
-  }
-  virtual webrtc::RtpParameters GetDefaultRtpReceiveParameters() const {
-    return webrtc::RtpParameters();
-  }
-
   bool IsStreamMuted(uint32_t ssrc) const {
     bool ret = muted_streams_.find(ssrc) != muted_streams_.end();
     // If |ssrc = 0| check if the first send stream is muted.
@@ -208,12 +334,6 @@ class RtpHelper : public Base {
   const std::vector<StreamParams>& send_streams() const {
     return send_streams_;
   }
-  const std::vector<StreamParams>& recv_streams() const {
-    return receive_streams_;
-  }
-  bool HasRecvStream(uint32_t ssrc) const {
-    return GetStreamBySsrc(receive_streams_, ssrc) != nullptr;
-  }
   bool HasSendStream(uint32_t ssrc) const {
     return GetStreamBySsrc(send_streams_, ssrc) != nullptr;
   }
@@ -225,15 +345,7 @@ class RtpHelper : public Base {
     return send_streams_[0].first_ssrc();
   }
 
-  // TODO(perkj): This is to support legacy unit test that only check one
-  // sending stream.
-  const std::string rtcp_cname() {
-    if (send_streams_.empty())
-      return "";
-    return send_streams_[0].cname;
-  }
   const RtcpParameters& send_rtcp_parameters() { return send_rtcp_parameters_; }
-  const RtcpParameters& recv_rtcp_parameters() { return recv_rtcp_parameters_; }
 
   bool ready_to_send() const { return ready_to_send_; }
 
@@ -261,18 +373,9 @@ class RtpHelper : public Base {
       rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
       override {}
 
-  void SetFrameDecryptor(uint32_t ssrc,
-                         rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
-                             frame_decryptor) override {}
-
-  void SetDepacketizerToDecoderFrameTransformer(
-      uint32_t ssrc,
-      rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
-      override {}
-
   void SetInterface(MediaChannelNetworkInterface* iface) override {
     network_interface_ = iface;
-    MediaChannel::SetInterface(iface);
+    MediaChannelUtil::SetInterface(iface);
   }
   bool HasNetworkInterface() const override {
     return network_interface_ != nullptr;
@@ -294,17 +397,6 @@ class RtpHelper : public Base {
     sending_ = send;
     return true;
   }
-  void set_playout(bool playout) { playout_ = playout; }
-  bool SetRecvRtpHeaderExtensions(const std::vector<RtpExtension>& extensions) {
-    recv_extensions_ = extensions;
-    return true;
-  }
-  bool SetSendExtmapAllowMixed(bool extmap_allow_mixed) {
-    if (Base::ExtmapAllowMixed() != extmap_allow_mixed) {
-      Base::SetExtmapAllowMixed(extmap_allow_mixed);
-    }
-    return true;
-  }
   bool SetSendRtpHeaderExtensions(const std::vector<RtpExtension>& extensions) {
     send_extensions_ = extensions;
     return true;
@@ -312,13 +404,6 @@ class RtpHelper : public Base {
   void set_send_rtcp_parameters(const RtcpParameters& params) {
     send_rtcp_parameters_ = params;
   }
-  void set_recv_rtcp_parameters(const RtcpParameters& params) {
-    recv_rtcp_parameters_ = params;
-  }
-  void OnPacketReceived(const webrtc::RtpPacketReceived& packet) override {
-    rtp_packets_.push_back(
-        std::string(packet.Buffer().cdata<char>(), packet.size()));
-  }
   void OnPacketSent(const rtc::SentPacket& sent_packet) override {}
   void OnReadyToSend(bool ready) override { ready_to_send_ = ready; }
   void OnNetworkRouteChanged(absl::string_view transport_name,
@@ -328,27 +413,20 @@ class RtpHelper : public Base {
     transport_overhead_per_packet_ = network_route.packet_overhead;
   }
   bool fail_set_send_codecs() const { return fail_set_send_codecs_; }
-  bool fail_set_recv_codecs() const { return fail_set_recv_codecs_; }
 
  private:
   // TODO(bugs.webrtc.org/12783): This flag is used from more than one thread.
   // As a workaround for tsan, it's currently std::atomic but that might not
   // be the appropriate fix.
   std::atomic<bool> sending_;
-  bool playout_;
-  std::vector<RtpExtension> recv_extensions_;
   std::vector<RtpExtension> send_extensions_;
   std::list<std::string> rtp_packets_;
   std::list<std::string> rtcp_packets_;
   std::vector<StreamParams> send_streams_;
-  std::vector<StreamParams> receive_streams_;
   RtcpParameters send_rtcp_parameters_;
-  RtcpParameters recv_rtcp_parameters_;
   std::set<uint32_t> muted_streams_;
   std::map<uint32_t, webrtc::RtpParameters> rtp_send_parameters_;
-  std::map<uint32_t, webrtc::RtpParameters> rtp_receive_parameters_;
   bool fail_set_send_codecs_;
-  bool fail_set_recv_codecs_;
   uint32_t send_ssrc_;
   std::string rtcp_cname_;
   bool ready_to_send_;
@@ -356,9 +434,12 @@ class RtpHelper : public Base {
   rtc::NetworkRoute last_network_route_;
   int num_network_route_changes_;
   MediaChannelNetworkInterface* network_interface_ = nullptr;
+  absl::AnyInvocable<void(const std::set<uint32_t>&)>
+      ssrc_list_changed_callback_ = nullptr;
 };
 
-class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
+class FakeVoiceMediaReceiveChannel
+    : public RtpReceiveChannelHelper<VoiceMediaReceiveChannelInterface> {
  public:
   struct DtmfInfo {
     DtmfInfo(uint32_t ssrc, int event_code, int duration);
@@ -366,36 +447,34 @@ class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
     int event_code;
     int duration;
   };
-  FakeVoiceMediaChannel(MediaChannel::Role role,
-                        FakeVoiceEngine* engine,
-                        const AudioOptions& options,
-                        webrtc::TaskQueueBase* network_thread);
-  ~FakeVoiceMediaChannel();
+  FakeVoiceMediaReceiveChannel(const AudioOptions& options,
+                               webrtc::TaskQueueBase* network_thread);
+  virtual ~FakeVoiceMediaReceiveChannel();
+
+  // Test methods
   const std::vector<AudioCodec>& recv_codecs() const;
-  const std::vector<AudioCodec>& send_codecs() const;
-  const std::vector<AudioCodec>& codecs() const;
   const std::vector<DtmfInfo>& dtmf_info_queue() const;
   const AudioOptions& options() const;
   int max_bps() const;
-  bool SetSendParameters(const AudioSendParameters& params) override;
+  bool HasSource(uint32_t ssrc) const;
+
+  // Overrides
+  VideoMediaReceiveChannelInterface* AsVideoReceiveChannel() override {
+    return nullptr;
+  }
+  VoiceMediaReceiveChannelInterface* AsVoiceReceiveChannel() override {
+    return this;
+  }
+  cricket::MediaType media_type() const override {
+    return cricket::MEDIA_TYPE_AUDIO;
+  }
 
   bool SetRecvParameters(const AudioRecvParameters& params) override;
-
   void SetPlayout(bool playout) override;
-  void SetSend(bool send) override;
-  bool SetAudioSend(uint32_t ssrc,
-                    bool enable,
-                    const AudioOptions* options,
-                    AudioSource* source) override;
-
-  bool HasSource(uint32_t ssrc) const;
 
   bool AddRecvStream(const StreamParams& sp) override;
   bool RemoveRecvStream(uint32_t ssrc) override;
 
-  bool CanInsertDtmf() override;
-  bool InsertDtmf(uint32_t ssrc, int event_code, int duration) override;
-
   bool SetOutputVolume(uint32_t ssrc, double volume) override;
   bool SetDefaultOutputVolume(double volume) override;
 
@@ -405,9 +484,8 @@ class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
   absl::optional<int> GetBaseMinimumPlayoutDelayMs(
       uint32_t ssrc) const override;
 
-  bool GetSendStats(VoiceMediaSendInfo* info) override;
-  bool GetReceiveStats(VoiceMediaReceiveInfo* info,
-                       bool get_and_clear_legacy_stats) override;
+  bool GetStats(VoiceMediaReceiveInfo* info,
+                bool get_and_clear_legacy_stats) override;
 
   void SetRawAudioSink(
       uint32_t ssrc,
@@ -416,14 +494,8 @@ class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
       std::unique_ptr<webrtc::AudioSinkInterface> sink) override;
 
   std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override;
-  bool SenderNackEnabled() const override { return false; }
-  bool SenderNonSenderRttEnabled() const override { return false; }
-  void SetReceiveNackEnabled(bool enabled) {}
-  void SetReceiveNonSenderRttEnabled(bool enabled) {}
-  bool SendCodecHasNack() const override { return false; }
-  void SetSendCodecChangedCallback(
-      absl::AnyInvocable<void()> callback) override {}
-  absl::optional<Codec> GetSendCodec() const override;
+  void SetReceiveNackEnabled(bool enabled) override {}
+  void SetReceiveNonSenderRttEnabled(bool enabled) override {}
 
  private:
   class VoiceChannelAudioSink : public AudioSource::Sink {
@@ -445,14 +517,10 @@ class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
   };
 
   bool SetRecvCodecs(const std::vector<AudioCodec>& codecs);
-  bool SetSendCodecs(const std::vector<AudioCodec>& codecs);
   bool SetMaxSendBandwidth(int bps);
   bool SetOptions(const AudioOptions& options);
-  bool SetLocalSource(uint32_t ssrc, AudioSource* source);
 
-  FakeVoiceEngine* engine_;
   std::vector<AudioCodec> recv_codecs_;
-  std::vector<AudioCodec> send_codecs_;
   std::map<uint32_t, double> output_scalings_;
   std::map<uint32_t, int> output_delays_;
   std::vector<DtmfInfo> dtmf_info_queue_;
@@ -462,56 +530,134 @@ class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
   int max_bps_;
 };
 
+class FakeVoiceMediaSendChannel
+    : public RtpSendChannelHelper<VoiceMediaSendChannelInterface> {
+ public:
+  struct DtmfInfo {
+    DtmfInfo(uint32_t ssrc, int event_code, int duration);
+    uint32_t ssrc;
+    int event_code;
+    int duration;
+  };
+  FakeVoiceMediaSendChannel(const AudioOptions& options,
+                            webrtc::TaskQueueBase* network_thread);
+  ~FakeVoiceMediaSendChannel() override;
+
+  const std::vector<AudioCodec>& send_codecs() const;
+  const std::vector<DtmfInfo>& dtmf_info_queue() const;
+  const AudioOptions& options() const;
+  int max_bps() const;
+  bool HasSource(uint32_t ssrc) const;
+  bool GetOutputVolume(uint32_t ssrc, double* volume);
+
+  // Overrides
+  VideoMediaSendChannelInterface* AsVideoSendChannel() override {
+    return nullptr;
+  }
+  VoiceMediaSendChannelInterface* AsVoiceSendChannel() override { return this; }
+  cricket::MediaType media_type() const override {
+    return cricket::MEDIA_TYPE_AUDIO;
+  }
+
+  bool SetSendParameters(const AudioSendParameters& params) override;
+  void SetSend(bool send) override;
+  bool SetAudioSend(uint32_t ssrc,
+                    bool enable,
+                    const AudioOptions* options,
+                    AudioSource* source) override;
+
+  bool CanInsertDtmf() override;
+  bool InsertDtmf(uint32_t ssrc, int event_code, int duration) override;
+
+  bool SenderNackEnabled() const override { return false; }
+  bool SenderNonSenderRttEnabled() const override { return false; }
+  void SetReceiveNackEnabled(bool enabled) {}
+  void SetReceiveNonSenderRttEnabled(bool enabled) {}
+  bool SendCodecHasNack() const override { return false; }
+  void SetSendCodecChangedCallback(
+      absl::AnyInvocable<void()> callback) override {}
+  absl::optional<Codec> GetSendCodec() const override;
+
+  bool GetStats(VoiceMediaSendInfo* stats) override;
+
+ private:
+  class VoiceChannelAudioSink : public AudioSource::Sink {
+   public:
+    explicit VoiceChannelAudioSink(AudioSource* source);
+    ~VoiceChannelAudioSink() override;
+    void OnData(const void* audio_data,
+                int bits_per_sample,
+                int sample_rate,
+                size_t number_of_channels,
+                size_t number_of_frames,
+                absl::optional<int64_t> absolute_capture_timestamp_ms) override;
+    void OnClose() override;
+    int NumPreferredChannels() const override { return -1; }
+    AudioSource* source() const;
+
+   private:
+    AudioSource* source_;
+  };
+
+  bool SetSendCodecs(const std::vector<AudioCodec>& codecs);
+  bool SetMaxSendBandwidth(int bps);
+  bool SetOptions(const AudioOptions& options);
+  bool SetLocalSource(uint32_t ssrc, AudioSource* source);
+
+  std::vector<AudioCodec> send_codecs_;
+  std::map<uint32_t, double> output_scalings_;
+  std::map<uint32_t, int> output_delays_;
+  std::vector<DtmfInfo> dtmf_info_queue_;
+  AudioOptions options_;
+  std::map<uint32_t, std::unique_ptr<VoiceChannelAudioSink>> local_sinks_;
+  int max_bps_;
+};
+
 // A helper function to compare the FakeVoiceMediaChannel::DtmfInfo.
-bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info,
+bool CompareDtmfInfo(const FakeVoiceMediaSendChannel::DtmfInfo& info,
                      uint32_t ssrc,
                      int event_code,
                      int duration);
 
-class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
+class FakeVideoMediaReceiveChannel
+    : public RtpReceiveChannelHelper<VideoMediaReceiveChannelInterface> {
  public:
-  FakeVideoMediaChannel(MediaChannel::Role role,
-                        FakeVideoEngine* engine,
-                        const VideoOptions& options,
-                        webrtc::TaskQueueBase* network_thread);
+  FakeVideoMediaReceiveChannel(const VideoOptions& options,
+                               webrtc::TaskQueueBase* network_thread);
 
-  ~FakeVideoMediaChannel();
+  virtual ~FakeVideoMediaReceiveChannel();
+
+  VideoMediaReceiveChannelInterface* AsVideoReceiveChannel() override {
+    return this;
+  }
+  VoiceMediaReceiveChannelInterface* AsVoiceReceiveChannel() override {
+    return nullptr;
+  }
+  cricket::MediaType media_type() const override {
+    return cricket::MEDIA_TYPE_VIDEO;
+  }
 
   const std::vector<VideoCodec>& recv_codecs() const;
   const std::vector<VideoCodec>& send_codecs() const;
-  const std::vector<VideoCodec>& codecs() const;
   bool rendering() const;
   const VideoOptions& options() const;
   const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
   sinks() const;
   int max_bps() const;
-  bool SetSendParameters(const VideoSendParameters& params) override;
   bool SetRecvParameters(const VideoRecvParameters& params) override;
-  bool AddSendStream(const StreamParams& sp) override;
-  bool RemoveSendStream(uint32_t ssrc) override;
 
-  absl::optional<Codec> GetSendCodec() const override;
   bool SetSink(uint32_t ssrc,
                rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override;
   void SetDefaultSink(
       rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override;
   bool HasSink(uint32_t ssrc) const;
 
-  bool SetSend(bool send) override;
   void SetReceive(bool receive) override {}
-  bool SetVideoSend(
-      uint32_t ssrc,
-      const VideoOptions* options,
-      rtc::VideoSourceInterface<webrtc::VideoFrame>* source) override;
 
   bool HasSource(uint32_t ssrc) const;
   bool AddRecvStream(const StreamParams& sp) override;
   bool RemoveRecvStream(uint32_t ssrc) override;
 
-  void FillBitrateInfo(BandwidthEstimationInfo* bwe_info) override;
-  bool GetSendStats(VideoMediaSendInfo* info) override;
-  bool GetReceiveStats(VideoMediaReceiveInfo* info) override;
-
   std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override;
 
   bool SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) override;
@@ -524,6 +670,67 @@ class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
       override;
   void ClearRecordableEncodedFrameCallback(uint32_t ssrc) override;
   void RequestRecvKeyFrame(uint32_t ssrc) override;
+  void SetReceiverFeedbackParameters(bool lntf_enabled,
+                                     bool nack_enabled,
+                                     webrtc::RtcpMode rtcp_mode,
+                                     absl::optional<int> rtx_time) override {}
+  bool GetStats(VideoMediaReceiveInfo* info) override;
+
+  bool AddDefaultRecvStreamForTesting(const StreamParams& sp) override {
+    RTC_CHECK_NOTREACHED();
+    return false;
+  }
+
+ private:
+  bool SetRecvCodecs(const std::vector<VideoCodec>& codecs);
+  bool SetSendCodecs(const std::vector<VideoCodec>& codecs);
+  bool SetOptions(const VideoOptions& options);
+  bool SetMaxSendBandwidth(int bps);
+
+  std::vector<VideoCodec> recv_codecs_;
+  std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*> sinks_;
+  std::map<uint32_t, rtc::VideoSourceInterface<webrtc::VideoFrame>*> sources_;
+  std::map<uint32_t, int> output_delays_;
+  VideoOptions options_;
+  int max_bps_;
+};
+
+class FakeVideoMediaSendChannel
+    : public RtpSendChannelHelper<VideoMediaSendChannelInterface> {
+ public:
+  FakeVideoMediaSendChannel(const VideoOptions& options,
+                            webrtc::TaskQueueBase* network_thread);
+
+  virtual ~FakeVideoMediaSendChannel();
+
+  VideoMediaSendChannelInterface* AsVideoSendChannel() override { return this; }
+  VoiceMediaSendChannelInterface* AsVoiceSendChannel() override {
+    return nullptr;
+  }
+  cricket::MediaType media_type() const override {
+    return cricket::MEDIA_TYPE_VIDEO;
+  }
+
+  const std::vector<VideoCodec>& send_codecs() const;
+  const std::vector<VideoCodec>& codecs() const;
+  const VideoOptions& options() const;
+  const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
+  sinks() const;
+  int max_bps() const;
+  bool SetSendParameters(const VideoSendParameters& params) override;
+
+  absl::optional<Codec> GetSendCodec() const override;
+
+  bool SetSend(bool send) override;
+  bool SetVideoSend(
+      uint32_t ssrc,
+      const VideoOptions* options,
+      rtc::VideoSourceInterface<webrtc::VideoFrame>* source) override;
+
+  bool HasSource(uint32_t ssrc) const;
+
+  void FillBitrateInfo(BandwidthEstimationInfo* bwe_info) override;
+
   void GenerateSendKeyFrame(uint32_t ssrc,
                             const std::vector<std::string>& rids) override;
   webrtc::RtcpMode SendCodecRtcpMode() const override {
@@ -534,28 +741,21 @@ class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
   void SetSsrcListChangedCallback(
       absl::AnyInvocable<void(const std::set<uint32_t>&)> callback) override {}
 
+  void SetVideoCodecSwitchingEnabled(bool enabled) override {}
   bool SendCodecHasLntf() const override { return false; }
   bool SendCodecHasNack() const override { return false; }
   absl::optional<int> SendCodecRtxTime() const override {
     return absl::nullopt;
   }
-  void SetReceiverFeedbackParameters(bool lntf_enabled,
-                                     bool nack_enabled,
-                                     webrtc::RtcpMode rtcp_mode,
-                                     absl::optional<int> rtx_time) override {}
+  bool GetStats(VideoMediaSendInfo* info) override;
 
  private:
-  bool SetRecvCodecs(const std::vector<VideoCodec>& codecs);
   bool SetSendCodecs(const std::vector<VideoCodec>& codecs);
   bool SetOptions(const VideoOptions& options);
   bool SetMaxSendBandwidth(int bps);
 
-  FakeVideoEngine* engine_;
-  std::vector<VideoCodec> recv_codecs_;
   std::vector<VideoCodec> send_codecs_;
-  std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*> sinks_;
   std::map<uint32_t, rtc::VideoSourceInterface<webrtc::VideoFrame>*> sources_;
-  std::map<uint32_t, int> output_delays_;
   VideoOptions options_;
   int max_bps_;
 };
@@ -566,16 +766,41 @@ class FakeVoiceEngine : public VoiceEngineInterface {
   void Init() override;
   rtc::scoped_refptr<webrtc::AudioState> GetAudioState() const override;
 
+  std::unique_ptr<VoiceMediaSendChannelInterface> CreateSendChannel(
+      webrtc::Call* call,
+      const MediaConfig& config,
+      const AudioOptions& options,
+      const webrtc::CryptoOptions& crypto_options,
+      webrtc::AudioCodecPairId codec_pair_id) override;
+  std::unique_ptr<VoiceMediaReceiveChannelInterface> CreateReceiveChannel(
+      webrtc::Call* call,
+      const MediaConfig& config,
+      const AudioOptions& options,
+      const webrtc::CryptoOptions& crypto_options,
+      webrtc::AudioCodecPairId codec_pair_id) override;
   VoiceMediaChannel* CreateMediaChannel(
       MediaChannel::Role role,
       webrtc::Call* call,
       const MediaConfig& config,
       const AudioOptions& options,
       const webrtc::CryptoOptions& crypto_options,
-      webrtc::AudioCodecPairId codec_pair_id) override;
-  FakeVoiceMediaChannel* GetSendChannel(size_t index);
-  FakeVoiceMediaChannel* GetReceiveChannel(size_t index);
-  void UnregisterChannel(VoiceMediaChannel* channel);
+      webrtc::AudioCodecPairId codec_pair_id) override {
+    RTC_DCHECK_RUN_ON(call->worker_thread());
+    std::unique_ptr<VoiceMediaSendChannelInterface> send_channel;
+    std::unique_ptr<VoiceMediaReceiveChannelInterface> receive_channel;
+    if (role == MediaChannel::Role::kSend ||
+        role == MediaChannel::Role::kBoth) {
+      send_channel = CreateSendChannel(call, config, options, crypto_options,
+                                       codec_pair_id);
+    }
+    if (role == MediaChannel::Role::kReceive ||
+        role == MediaChannel::Role::kBoth) {
+      receive_channel = CreateReceiveChannel(call, config, options,
+                                             crypto_options, codec_pair_id);
+    }
+    return new VoiceMediaShimChannel(std::move(send_channel),
+                                     std::move(receive_channel));
+  }
 
   // TODO(ossu): For proper testing, These should either individually settable
   //             or the voice engine should reference mockable factories.
@@ -595,8 +820,6 @@ class FakeVoiceEngine : public VoiceEngineInterface {
       std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions);
 
  private:
-  std::vector<FakeVoiceMediaChannel*> send_channels_;
-  std::vector<FakeVoiceMediaChannel*> receive_channels_;
   std::vector<AudioCodec> recv_codecs_;
   std::vector<AudioCodec> send_codecs_;
   bool fail_create_channel_;
@@ -609,6 +832,18 @@ class FakeVideoEngine : public VideoEngineInterface {
  public:
   FakeVideoEngine();
   bool SetOptions(const VideoOptions& options);
+  std::unique_ptr<VideoMediaSendChannelInterface> CreateSendChannel(
+      webrtc::Call* call,
+      const MediaConfig& config,
+      const VideoOptions& options,
+      const webrtc::CryptoOptions& crypto_options,
+      webrtc::VideoBitrateAllocatorFactory* video_bitrate_allocator_factory)
+      override;
+  std::unique_ptr<VideoMediaReceiveChannelInterface> CreateReceiveChannel(
+      webrtc::Call* call,
+      const MediaConfig& config,
+      const VideoOptions& options,
+      const webrtc::CryptoOptions& crypto_options) override;
   VideoMediaChannel* CreateMediaChannel(
       MediaChannel::Role role,
       webrtc::Call* call,
@@ -616,10 +851,26 @@ class FakeVideoEngine : public VideoEngineInterface {
       const VideoOptions& options,
       const webrtc::CryptoOptions& crypto_options,
       webrtc::VideoBitrateAllocatorFactory* video_bitrate_allocator_factory)
-      override;
-  FakeVideoMediaChannel* GetSendChannel(size_t index);
-  FakeVideoMediaChannel* GetReceiveChannel(size_t index);
-  void UnregisterChannel(VideoMediaChannel* channel);
+      override {
+    RTC_LOG(LS_INFO) << "CreateMediaChannel. Options: " << options.ToString();
+    std::unique_ptr<VideoMediaSendChannelInterface> send_channel;
+    std::unique_ptr<VideoMediaReceiveChannelInterface> receive_channel;
+    if (role == MediaChannel::Role::kSend ||
+        role == MediaChannel::Role::kBoth) {
+      send_channel = CreateSendChannel(call, config, options, crypto_options,
+                                       video_bitrate_allocator_factory);
+    }
+    if (role == MediaChannel::Role::kReceive ||
+        role == MediaChannel::Role::kBoth) {
+      receive_channel =
+          CreateReceiveChannel(call, config, options, crypto_options);
+    }
+    return new VideoMediaShimChannel(std::move(send_channel),
+                                     std::move(receive_channel));
+  }
+  FakeVideoMediaSendChannel* GetSendChannel(size_t index);
+  FakeVideoMediaReceiveChannel* GetReceiveChannel(size_t index);
+
   std::vector<VideoCodec> send_codecs() const override {
     return send_codecs(true);
   }
@@ -637,8 +888,6 @@ class FakeVideoEngine : public VideoEngineInterface {
       std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions);
 
  private:
-  std::vector<FakeVideoMediaChannel*> send_channels_;
-  std::vector<FakeVideoMediaChannel*> receive_channels_;
   std::vector<VideoCodec> send_codecs_;
   std::vector<VideoCodec> recv_codecs_;
   bool capture_;
@@ -660,13 +909,11 @@ class FakeMediaEngine : public CompositeMediaEngine {
   void SetAudioSendCodecs(const std::vector<AudioCodec>& codecs);
   void SetVideoCodecs(const std::vector<VideoCodec>& codecs);
 
-  FakeVoiceMediaChannel* GetVoiceSendChannel(size_t index);
-  FakeVideoMediaChannel* GetVideoSendChannel(size_t index);
-  FakeVoiceMediaChannel* GetVoiceReceiveChannel(size_t index);
-  FakeVideoMediaChannel* GetVideoReceiveChannel(size_t index);
-
   void set_fail_create_channel(bool fail);
 
+  FakeVoiceEngine* fake_voice_engine() { return voice_; }
+  FakeVideoEngine* fake_video_engine() { return video_; }
+
  private:
   FakeVoiceEngine* const voice_;
   FakeVideoEngine* const video_;
diff --git a/pc/channel_unittest.cc b/pc/channel_unittest.cc
index 28676291bf..0d7f0b0cd0 100644
--- a/pc/channel_unittest.cc
+++ b/pc/channel_unittest.cc
@@ -49,7 +49,8 @@
 #include "test/scoped_key_value_config.h"
 
 using cricket::DtlsTransportInternal;
-using cricket::FakeVoiceMediaChannel;
+using cricket::FakeVoiceMediaReceiveChannel;
+using cricket::FakeVoiceMediaSendChannel;
 using cricket::RidDescription;
 using cricket::RidDirection;
 using cricket::StreamParams;
@@ -77,9 +78,10 @@ enum class NetworkIsWorker { Yes, No };
 }  // namespace
 
 template <class ChannelT,
-          class MediaChannelT,
           class MediaSendChannelT,
           class MediaReceiveChannelT,
+          class MediaSendChannelInterfaceT,
+          class MediaReceiveChannelInterfaceT,
           class ContentT,
           class CodecT,
           class MediaInfoT,
@@ -87,9 +89,10 @@ template <class ChannelT,
 class Traits {
  public:
   typedef ChannelT Channel;
-  typedef MediaChannelT MediaChannel;
   typedef MediaSendChannelT MediaSendChannel;
   typedef MediaReceiveChannelT MediaReceiveChannel;
+  typedef MediaSendChannelInterfaceT MediaSendChannelInterface;
+  typedef MediaReceiveChannelInterfaceT MediaReceiveChannelInterface;
   typedef ContentT Content;
   typedef CodecT Codec;
   typedef MediaInfoT MediaInfo;
@@ -97,7 +100,8 @@ class Traits {
 };
 
 class VoiceTraits : public Traits<cricket::VoiceChannel,
-                                  cricket::FakeVoiceMediaChannel,
+                                  cricket::FakeVoiceMediaSendChannel,
+                                  cricket::FakeVoiceMediaReceiveChannel,
                                   cricket::VoiceMediaSendChannelInterface,
                                   cricket::VoiceMediaReceiveChannelInterface,
                                   cricket::AudioContentDescription,
@@ -106,7 +110,8 @@ class VoiceTraits : public Traits<cricket::VoiceChannel,
                                   cricket::AudioOptions> {};
 
 class VideoTraits : public Traits<cricket::VideoChannel,
-                                  cricket::FakeVideoMediaChannel,
+                                  cricket::FakeVideoMediaSendChannel,
+                                  cricket::FakeVideoMediaReceiveChannel,
                                   cricket::VideoMediaSendChannelInterface,
                                   cricket::VideoMediaReceiveChannelInterface,
                                   cricket::VideoContentDescription,
@@ -154,24 +159,20 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
   }
 
   void CreateChannels(int flags1, int flags2) {
-    CreateChannels(std::make_unique<typename T::MediaChannel>(
-                       cricket::MediaChannel::Role::kSend, nullptr,
+    CreateChannels(std::make_unique<typename T::MediaSendChannel>(
                        typename T::Options(), network_thread_),
-                   std::make_unique<typename T::MediaChannel>(
-                       cricket::MediaChannel::Role::kReceive, nullptr,
+                   std::make_unique<typename T::MediaReceiveChannel>(
                        typename T::Options(), network_thread_),
-                   std::make_unique<typename T::MediaChannel>(
-                       cricket::MediaChannel::Role::kSend, nullptr,
+                   std::make_unique<typename T::MediaSendChannel>(
                        typename T::Options(), network_thread_),
-                   std::make_unique<typename T::MediaChannel>(
-                       cricket::MediaChannel::Role::kReceive, nullptr,
+                   std::make_unique<typename T::MediaReceiveChannel>(
                        typename T::Options(), network_thread_),
                    flags1, flags2);
   }
-  void CreateChannels(std::unique_ptr<typename T::MediaChannel> ch1s,
-                      std::unique_ptr<typename T::MediaChannel> ch1r,
-                      std::unique_ptr<typename T::MediaChannel> ch2s,
-                      std::unique_ptr<typename T::MediaChannel> ch2r,
+  void CreateChannels(std::unique_ptr<typename T::MediaSendChannel> ch1s,
+                      std::unique_ptr<typename T::MediaReceiveChannel> ch1r,
+                      std::unique_ptr<typename T::MediaSendChannel> ch2s,
+                      std::unique_ptr<typename T::MediaReceiveChannel> ch2r,
                       int flags1,
                       int flags2) {
     RTC_DCHECK(!channel1_);
@@ -275,8 +276,8 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
   std::unique_ptr<typename T::Channel> CreateChannel(
       rtc::Thread* worker_thread,
       rtc::Thread* network_thread,
-      std::unique_ptr<typename T::MediaChannel> ch_send,
-      std::unique_ptr<typename T::MediaChannel> ch_receive,
+      std::unique_ptr<typename T::MediaSendChannel> ch_send,
+      std::unique_ptr<typename T::MediaReceiveChannel> ch_receive,
       webrtc::RtpTransportInternal* rtp_transport,
       int flags);
 
@@ -439,11 +440,11 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     return result;
   }
 
-  void SendRtp(typename T::MediaChannel* media_channel, rtc::Buffer data) {
+  void SendRtp(typename T::MediaSendChannel* media_channel, rtc::Buffer data) {
     network_thread_->PostTask(webrtc::SafeTask(
         network_thread_safety_, [media_channel, data = std::move(data)]() {
-          media_channel->SendRtp(data.data(), data.size(),
-                                 rtc::PacketOptions());
+          media_channel->SendPacket(data.data(), data.size(),
+                                    rtc::PacketOptions());
         }));
   }
 
@@ -586,7 +587,7 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     if (verify_playout_) {
       EXPECT_FALSE(media_receive_channel1_impl()->playout());
     }
-    EXPECT_TRUE(media_send_channel1_impl()->codecs().empty());
+    EXPECT_TRUE(media_send_channel1_impl()->send_codecs().empty());
     EXPECT_TRUE(media_receive_channel1_impl()->recv_streams().empty());
     EXPECT_TRUE(media_send_channel1_impl()->rtp_packets().empty());
     // Basic sanity test for send and receive channel objects
@@ -606,11 +607,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_impl()->codecs().size());
+    EXPECT_EQ(0U, media_send_channel1_impl()->send_codecs().size());
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, err));
-    ASSERT_EQ(1U, media_send_channel1_impl()->codecs().size());
+    ASSERT_EQ(1U, media_send_channel1_impl()->send_codecs().size());
     EXPECT_TRUE(CodecMatches(content.codecs()[0],
-                             media_send_channel1_impl()->codecs()[0]));
+                             media_send_channel1_impl()->send_codecs()[0]));
   }
 
   // Test that SetLocalContent and SetRemoteContent properly configure
@@ -654,11 +655,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_impl()->codecs().size());
+    EXPECT_EQ(0U, media_send_channel1_impl()->send_codecs().size());
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, err));
-    ASSERT_EQ(1U, media_send_channel1_impl()->codecs().size());
+    ASSERT_EQ(1U, media_send_channel1_impl()->send_codecs().size());
     EXPECT_TRUE(CodecMatches(content.codecs()[0],
-                             media_send_channel1_impl()->codecs()[0]));
+                             media_send_channel1_impl()->send_codecs()[0]));
   }
 
   // Test that SetLocalContent and SetRemoteContent properly set RTCP
@@ -911,7 +912,7 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     CreateChannels(DTLS, DTLS);
     SendInitiate();
 
-    typename T::MediaChannel* media_send_channel1_impl =
+    typename T::MediaSendChannel* media_send_channel1_impl =
         this->media_send_channel1_impl();
     ASSERT_TRUE(media_send_channel1_impl);
 
@@ -973,12 +974,12 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     EXPECT_TRUE(SendAccept());
     EXPECT_FALSE(IsSrtpActive(channel1_));
     EXPECT_TRUE(media_send_channel1_impl()->sending());
-    EXPECT_EQ(1U, media_send_channel1_impl()->codecs().size());
+    EXPECT_EQ(1U, media_send_channel1_impl()->send_codecs().size());
     if (verify_playout_) {
       EXPECT_TRUE(media_receive_channel2_impl()->playout());
     }
     EXPECT_TRUE(media_send_channel2_impl()->sending());
-    EXPECT_EQ(1U, media_send_channel2_impl()->codecs().size());
+    EXPECT_EQ(1U, media_send_channel2_impl()->send_codecs().size());
   }
 
   // Send voice RTP data to the other side and ensure it gets there.
@@ -1457,46 +1458,47 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
   }
 
   // Accessors that return the standard VideoMedia{Send|Receive}ChannelInterface
-  typename T::MediaSendChannel* media_send_channel1() {
+  typename T::MediaSendChannelInterface* media_send_channel1() {
     return channel1_->media_send_channel();
   }
-  typename T::MediaSendChannel* media_send_channel2() {
+  typename T::MediaSendChannelInterface* media_send_channel2() {
     return channel2_->media_send_channel();
   }
-  typename T::MediaReceiveChannel* media_receive_channel1() {
+  typename T::MediaReceiveChannelInterface* media_receive_channel1() {
     return channel1_->media_receive_channel();
   }
-  typename T::MediaReceiveChannel* media_receive_channel2() {
+  typename T::MediaReceiveChannelInterface* media_receive_channel2() {
     return channel2_->media_receive_channel();
   }
 
-  // Accessors that return the FakeMedia<type>Channel object.
+  // Accessors that return the FakeMedia<type>SendChannel object.
   // Note that these depend on getting the object back that was
   // passed to the channel constructor.
-  // T::MediaChannel is either FakeVoiceMediaChannel or FakeVideoMediaChannel.
-  typename T::MediaChannel* media_send_channel1_impl() {
+  // T::MediaSendChannel is either FakeVoiceMediaSendChannel or
+  // FakeVideoMediaSendChannel.
+  typename T::MediaSendChannel* media_send_channel1_impl() {
     RTC_DCHECK(channel1_);
-    return static_cast<typename T::MediaChannel*>(
+    return static_cast<typename T::MediaSendChannel*>(
         channel1_->media_send_channel());
   }
 
-  typename T::MediaChannel* media_send_channel2_impl() {
+  typename T::MediaSendChannel* media_send_channel2_impl() {
     RTC_DCHECK(channel2_);
     RTC_DCHECK(channel2_->media_send_channel());
-    return static_cast<typename T::MediaChannel*>(
+    return static_cast<typename T::MediaSendChannel*>(
         channel2_->media_send_channel());
   }
-  typename T::MediaChannel* media_receive_channel1_impl() {
+  typename T::MediaReceiveChannel* media_receive_channel1_impl() {
     RTC_DCHECK(channel1_);
     RTC_DCHECK(channel1_->media_receive_channel());
-    return static_cast<typename T::MediaChannel*>(
+    return static_cast<typename T::MediaReceiveChannel*>(
         channel1_->media_receive_channel());
   }
 
-  typename T::MediaChannel* media_receive_channel2_impl() {
+  typename T::MediaReceiveChannel* media_receive_channel2_impl() {
     RTC_DCHECK(channel2_);
     RTC_DCHECK(channel2_->media_receive_channel());
-    return static_cast<typename T::MediaChannel*>(
+    return static_cast<typename T::MediaReceiveChannel*>(
         channel2_->media_receive_channel());
   }
 
@@ -1538,8 +1540,8 @@ template <>
 std::unique_ptr<cricket::VoiceChannel> ChannelTest<VoiceTraits>::CreateChannel(
     rtc::Thread* worker_thread,
     rtc::Thread* network_thread,
-    std::unique_ptr<cricket::FakeVoiceMediaChannel> send_ch,
-    std::unique_ptr<cricket::FakeVoiceMediaChannel> receive_ch,
+    std::unique_ptr<cricket::FakeVoiceMediaSendChannel> send_ch,
+    std::unique_ptr<cricket::FakeVoiceMediaReceiveChannel> receive_ch,
     webrtc::RtpTransportInternal* rtp_transport,
     int flags) {
   rtc::Thread* signaling_thread = rtc::Thread::Current();
@@ -1625,8 +1627,8 @@ template <>
 std::unique_ptr<cricket::VideoChannel> ChannelTest<VideoTraits>::CreateChannel(
     rtc::Thread* worker_thread,
     rtc::Thread* network_thread,
-    std::unique_ptr<cricket::FakeVideoMediaChannel> send_ch,
-    std::unique_ptr<cricket::FakeVideoMediaChannel> receive_ch,
+    std::unique_ptr<cricket::FakeVideoMediaSendChannel> send_ch,
+    std::unique_ptr<cricket::FakeVideoMediaReceiveChannel> receive_ch,
     webrtc::RtpTransportInternal* rtp_transport,
     int flags) {
   rtc::Thread* signaling_thread = rtc::Thread::Current();
diff --git a/pc/peer_connection_media_unittest.cc b/pc/peer_connection_media_unittest.cc
index 72bd9bda79..87e018b83e 100644
--- a/pc/peer_connection_media_unittest.cc
+++ b/pc/peer_connection_media_unittest.cc
@@ -43,6 +43,7 @@
 #include "api/task_queue/task_queue_factory.h"
 #include "media/base/codec.h"
 #include "media/base/fake_media_engine.h"
+#include "media/base/media_channel.h"
 #include "media/base/media_constants.h"
 #include "media/base/media_engine.h"
 #include "media/base/stream_params.h"
@@ -50,9 +51,11 @@
 #include "p2p/base/p2p_constants.h"
 #include "p2p/base/port_allocator.h"
 #include "p2p/base/transport_info.h"
+#include "pc/channel_interface.h"
 #include "pc/media_session.h"
 #include "pc/peer_connection_wrapper.h"
 #include "pc/rtp_media_utils.h"
+#include "pc/rtp_transceiver.h"
 #include "pc/session_description.h"
 #include "pc/test/mock_peer_connection_observers.h"
 #include "rtc_base/checks.h"
@@ -78,6 +81,47 @@ using ::testing::ElementsAre;
 using ::testing::NotNull;
 using ::testing::Values;
 
+cricket::MediaSendChannelInterface* SendChannelInternal(
+    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+  auto transceiver_with_internal = static_cast<rtc::RefCountedObject<
+      webrtc::RtpTransceiverProxyWithInternal<webrtc::RtpTransceiver>>*>(
+      transceiver.get());
+  auto transceiver_internal =
+      static_cast<RtpTransceiver*>(transceiver_with_internal->internal());
+  return transceiver_internal->channel()->media_send_channel();
+}
+
+cricket::MediaReceiveChannelInterface* ReceiveChannelInternal(
+    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+  auto transceiver_with_internal = static_cast<rtc::RefCountedObject<
+      webrtc::RtpTransceiverProxyWithInternal<webrtc::RtpTransceiver>>*>(
+      transceiver.get());
+  auto transceiver_internal =
+      static_cast<RtpTransceiver*>(transceiver_with_internal->internal());
+  return transceiver_internal->channel()->media_receive_channel();
+}
+
+cricket::FakeVideoMediaSendChannel* VideoMediaSendChannel(
+    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+  return static_cast<cricket::FakeVideoMediaSendChannel*>(
+      SendChannelInternal(transceiver));
+}
+cricket::FakeVideoMediaReceiveChannel* VideoMediaReceiveChannel(
+    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+  return static_cast<cricket::FakeVideoMediaReceiveChannel*>(
+      ReceiveChannelInternal(transceiver));
+}
+cricket::FakeVoiceMediaSendChannel* VoiceMediaSendChannel(
+    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+  return static_cast<cricket::FakeVoiceMediaSendChannel*>(
+      SendChannelInternal(transceiver));
+}
+cricket::FakeVoiceMediaReceiveChannel* VoiceMediaReceiveChannel(
+    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+  return static_cast<cricket::FakeVoiceMediaReceiveChannel*>(
+      ReceiveChannelInternal(transceiver));
+}
+
 class PeerConnectionWrapperForMediaTest : public PeerConnectionWrapper {
  public:
   using PeerConnectionWrapper::PeerConnectionWrapper;
@@ -272,7 +316,8 @@ std::vector<std::string> GetIds(
 // Test that exchanging an offer and answer with each side having an audio and
 // video stream creates the appropriate send/recv streams in the underlying
 // media engine on both sides.
-TEST_P(PeerConnectionMediaTest, AudioVideoOfferAnswerCreateSendRecvStreams) {
+TEST_F(PeerConnectionMediaTestUnifiedPlan,
+       AudioVideoOfferAnswerCreateSendRecvStreams) {
   const std::string kCallerAudioId = "caller_a";
   const std::string kCallerVideoId = "caller_v";
   const std::string kCalleeAudioId = "callee_a";
@@ -290,33 +335,37 @@ TEST_P(PeerConnectionMediaTest, AudioVideoOfferAnswerCreateSendRecvStreams) {
   ASSERT_TRUE(
       caller->SetRemoteDescription(callee->CreateAnswerAndSetAsLocal()));
 
-  auto* caller_voice_send = caller->media_engine()->GetVoiceSendChannel(0);
+  auto* caller_voice_send =
+      VoiceMediaSendChannel(caller->pc()->GetTransceivers()[0]);
   auto* caller_voice_receive =
-      caller->media_engine()->GetVoiceReceiveChannel(0);
+      VoiceMediaReceiveChannel(caller->pc()->GetTransceivers()[0]);
   EXPECT_THAT(GetIds(caller_voice_receive->recv_streams()),
               ElementsAre(kCalleeAudioId));
   EXPECT_THAT(GetIds(caller_voice_send->send_streams()),
               ElementsAre(kCallerAudioId));
 
-  auto* caller_video_send = caller->media_engine()->GetVideoSendChannel(0);
+  auto* caller_video_send =
+      VideoMediaSendChannel(caller->pc()->GetTransceivers()[1]);
   auto* caller_video_receive =
-      caller->media_engine()->GetVideoReceiveChannel(0);
+      VideoMediaReceiveChannel(caller->pc()->GetTransceivers()[1]);
   EXPECT_THAT(GetIds(caller_video_receive->recv_streams()),
               ElementsAre(kCalleeVideoId));
   EXPECT_THAT(GetIds(caller_video_send->send_streams()),
               ElementsAre(kCallerVideoId));
 
-  auto* callee_voice_send = callee->media_engine()->GetVoiceSendChannel(0);
+  auto* callee_voice_send =
+      VoiceMediaSendChannel(callee->pc()->GetTransceivers()[0]);
   auto* callee_voice_receive =
-      callee->media_engine()->GetVoiceReceiveChannel(0);
+      VoiceMediaReceiveChannel(callee->pc()->GetTransceivers()[0]);
   EXPECT_THAT(GetIds(callee_voice_receive->recv_streams()),
               ElementsAre(kCallerAudioId));
   EXPECT_THAT(GetIds(callee_voice_send->send_streams()),
               ElementsAre(kCalleeAudioId));
 
-  auto* callee_video_send = callee->media_engine()->GetVideoSendChannel(0);
+  auto* callee_video_send =
+      VideoMediaSendChannel(callee->pc()->GetTransceivers()[1]);
   auto* callee_video_receive =
-      callee->media_engine()->GetVideoReceiveChannel(0);
+      VideoMediaReceiveChannel(callee->pc()->GetTransceivers()[1]);
   EXPECT_THAT(GetIds(callee_video_receive->recv_streams()),
               ElementsAre(kCallerVideoId));
   EXPECT_THAT(GetIds(callee_video_send->send_streams()),
@@ -342,10 +391,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
 
   ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
 
-  ASSERT_FALSE(callee->media_engine()->GetVoiceSendChannel(0));
-  ASSERT_FALSE(callee->media_engine()->GetVideoSendChannel(0));
-  ASSERT_FALSE(callee->media_engine()->GetVoiceReceiveChannel(0));
-  ASSERT_FALSE(callee->media_engine()->GetVideoReceiveChannel(0));
+  ASSERT_TRUE(callee->pc()->GetTransceivers().empty());
 }
 
 // Test that removing streams from a subsequent offer causes the receive streams
@@ -365,14 +411,8 @@ TEST_F(PeerConnectionMediaTestPlanB, EmptyRemoteOfferRemovesRecvStreams) {
 
   ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
 
-  auto callee_voice_send = callee->media_engine()->GetVoiceSendChannel(0);
-  auto callee_video_send = callee->media_engine()->GetVideoSendChannel(0);
-  auto callee_voice_receive = callee->media_engine()->GetVoiceReceiveChannel(0);
-  auto callee_video_receive = callee->media_engine()->GetVideoReceiveChannel(0);
-  EXPECT_EQ(1u, callee_voice_send->send_streams().size());
-  EXPECT_EQ(0u, callee_voice_receive->recv_streams().size());
-  EXPECT_EQ(1u, callee_video_send->send_streams().size());
-  EXPECT_EQ(0u, callee_video_receive->recv_streams().size());
+  EXPECT_TRUE(callee->pc()->GetReceivers().empty());
+  EXPECT_EQ(2u, callee->pc()->GetSenders().size());
 }
 
 // Test enabling of simulcast with Plan B semantics.
@@ -444,8 +484,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
 
   ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
 
-  EXPECT_FALSE(callee->media_engine()->GetVoiceReceiveChannel(0));
-  EXPECT_FALSE(callee->media_engine()->GetVideoReceiveChannel(0));
+  EXPECT_TRUE(callee->pc()->GetTransceivers().empty());
 }
 
 // Test that removing streams from a subsequent answer causes the send streams
@@ -465,14 +504,8 @@ TEST_F(PeerConnectionMediaTestPlanB, EmptyLocalAnswerRemovesSendStreams) {
 
   ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
 
-  auto callee_voice_send = callee->media_engine()->GetVoiceSendChannel(0);
-  auto callee_voice_receive = callee->media_engine()->GetVoiceReceiveChannel(0);
-  auto callee_video_send = callee->media_engine()->GetVideoSendChannel(0);
-  auto callee_video_receive = callee->media_engine()->GetVideoReceiveChannel(0);
-  EXPECT_EQ(0u, callee_voice_send->send_streams().size());
-  EXPECT_EQ(1u, callee_voice_receive->recv_streams().size());
-  EXPECT_EQ(0u, callee_video_send->send_streams().size());
-  EXPECT_EQ(1u, callee_video_receive->recv_streams().size());
+  EXPECT_TRUE(callee->pc()->GetSenders().empty());
+  EXPECT_EQ(2u, callee->pc()->GetReceivers().size());
 }
 
 // Test that a new stream in a subsequent offer causes a new receive stream to
@@ -489,11 +522,12 @@ TEST_P(PeerConnectionMediaTest, NewStreamInRemoteOfferAddsRecvStreams) {
 
   ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
 
-  auto a1 = callee->media_engine()->GetVoiceReceiveChannel(0);
-  auto a2 = callee->media_engine()->GetVoiceReceiveChannel(1);
-  auto v1 = callee->media_engine()->GetVideoReceiveChannel(0);
-  auto v2 = callee->media_engine()->GetVideoReceiveChannel(1);
   if (IsUnifiedPlan()) {
+    auto a1 = VoiceMediaReceiveChannel(callee->pc()->GetTransceivers()[0]);
+    auto a2 = VoiceMediaReceiveChannel(callee->pc()->GetTransceivers()[2]);
+    auto v1 = VideoMediaReceiveChannel(callee->pc()->GetTransceivers()[1]);
+    auto v2 = VideoMediaReceiveChannel(callee->pc()->GetTransceivers()[3]);
+
     ASSERT_TRUE(a1);
     EXPECT_EQ(1u, a1->recv_streams().size());
     ASSERT_TRUE(a2);
@@ -503,12 +537,7 @@ TEST_P(PeerConnectionMediaTest, NewStreamInRemoteOfferAddsRecvStreams) {
     ASSERT_TRUE(v2);
     EXPECT_EQ(1u, v2->recv_streams().size());
   } else {
-    ASSERT_TRUE(a1);
-    EXPECT_EQ(2u, a1->recv_streams().size());
-    ASSERT_FALSE(a2);
-    ASSERT_TRUE(v1);
-    EXPECT_EQ(2u, v1->recv_streams().size());
-    ASSERT_FALSE(v2);
+    EXPECT_EQ(4u, callee->pc()->GetReceivers().size());
   }
 }
 
@@ -535,17 +564,18 @@ TEST_P(PeerConnectionMediaTest, NewStreamInLocalAnswerAddsSendStreams) {
   ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get(), offer_options,
                                               answer_options));
 
-  auto callee_voice = callee->media_engine()->GetVoiceSendChannel(0);
-  ASSERT_TRUE(callee_voice);
-  auto callee_video = callee->media_engine()->GetVideoSendChannel(0);
-  ASSERT_TRUE(callee_video);
-
   if (IsUnifiedPlan()) {
+    auto callee_voice =
+        VoiceMediaSendChannel(callee->pc()->GetTransceivers()[0]);
+    ASSERT_TRUE(callee_voice);
+    auto callee_video =
+        VideoMediaSendChannel(callee->pc()->GetTransceivers()[1]);
+    ASSERT_TRUE(callee_video);
+
     EXPECT_EQ(1u, callee_voice->send_streams().size());
     EXPECT_EQ(1u, callee_video->send_streams().size());
   } else {
-    EXPECT_EQ(2u, callee_voice->send_streams().size());
-    EXPECT_EQ(2u, callee_video->send_streams().size());
+    EXPECT_EQ(4u, callee->pc()->GetSenders().size());
   }
 }
 
@@ -1088,158 +1118,18 @@ INSTANTIATE_TEST_SUITE_P(
                                    ChangeMediaTypeAudioToVideo,
                                    kMLinesOutOfOrder))));
 
-// Test that the correct media engine send/recv streams are created when doing
-// a series of offer/answers where audio/video are both sent, then audio is
-// rejected, then both audio/video sent again.
-TEST_P(PeerConnectionMediaTest, TestAVOfferWithAudioOnlyAnswer) {
-  if (IsUnifiedPlan()) {
-    // offer_to_receive_ is not implemented when creating answers with Unified
-    // Plan semantics specified.
-    return;
-  }
-
-  RTCOfferAnswerOptions options_reject_video;
-  options_reject_video.offer_to_receive_audio =
-      RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
-  options_reject_video.offer_to_receive_video = 0;
-
-  auto caller = CreatePeerConnection();
-  caller->AddAudioTrack("a");
-  caller->AddVideoTrack("v");
-  auto callee = CreatePeerConnection();
-
-  // Caller initially offers to send/recv audio and video.
-  ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
-  // Callee accepts the audio as recv only but rejects the video.
-  ASSERT_TRUE(caller->SetRemoteDescription(
-      callee->CreateAnswerAndSetAsLocal(options_reject_video)));
-
-  auto caller_voice_send = caller->media_engine()->GetVoiceSendChannel(0);
-  auto caller_voice_receive = caller->media_engine()->GetVoiceReceiveChannel(0);
-  ASSERT_TRUE(caller_voice_send && caller_voice_receive);
-  EXPECT_EQ(0u, caller_voice_receive->recv_streams().size());
-  EXPECT_EQ(1u, caller_voice_send->send_streams().size());
-  auto caller_video = caller->media_engine()->GetVideoSendChannel(0);
-  EXPECT_FALSE(caller_video);
-
-  // Callee adds its own audio/video stream and offers to receive audio/video
-  // too.
-  callee->AddAudioTrack("a");
-  auto callee_video_track = callee->AddVideoTrack("v");
-  ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
-  ASSERT_TRUE(
-      caller->SetRemoteDescription(callee->CreateAnswerAndSetAsLocal()));
-
-  auto callee_voice_send = callee->media_engine()->GetVoiceSendChannel(0);
-  auto callee_voice_receive = callee->media_engine()->GetVoiceReceiveChannel(0);
-  ASSERT_TRUE(callee_voice_send && callee_voice_receive);
-  EXPECT_EQ(1u, callee_voice_receive->recv_streams().size());
-  EXPECT_EQ(1u, callee_voice_send->send_streams().size());
-  auto callee_video_send = callee->media_engine()->GetVideoSendChannel(0);
-  auto callee_video_receive = callee->media_engine()->GetVideoReceiveChannel(0);
-  ASSERT_TRUE(callee_video_send && callee_video_receive);
-  EXPECT_EQ(1u, callee_video_receive->recv_streams().size());
-  EXPECT_EQ(1u, callee_video_send->send_streams().size());
-
-  // Callee removes video but keeps audio and rejects the video once again.
-  callee->pc()->RemoveTrackOrError(callee_video_track);
-  ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
-  ASSERT_TRUE(
-      callee->SetLocalDescription(callee->CreateAnswer(options_reject_video)));
-
-  callee_voice_send = callee->media_engine()->GetVoiceSendChannel(0);
-  callee_voice_receive = callee->media_engine()->GetVoiceReceiveChannel(0);
-  ASSERT_TRUE(callee_voice_send && callee_voice_receive);
-  EXPECT_EQ(1u, callee_voice_receive->recv_streams().size());
-  EXPECT_EQ(1u, callee_voice_send->send_streams().size());
-  auto callee_video = callee->media_engine()->GetVideoSendChannel(0);
-  EXPECT_FALSE(callee_video);
-}
-
-// Test that the correct media engine send/recv streams are created when doing
-// a series of offer/answers where audio/video are both sent, then video is
-// rejected, then both audio/video sent again.
-TEST_P(PeerConnectionMediaTest, TestAVOfferWithVideoOnlyAnswer) {
-  if (IsUnifiedPlan()) {
-    // offer_to_receive_ is not implemented when creating answers with Unified
-    // Plan semantics specified.
-    return;
-  }
-
-  // Disable the bundling here. If the media is bundled on audio
-  // transport, then we can't reject the audio because switching the bundled
-  // transport is not currently supported.
-  // (https://bugs.chromium.org/p/webrtc/issues/detail?id=6704)
-  RTCOfferAnswerOptions options_no_bundle;
-  options_no_bundle.use_rtp_mux = false;
-  RTCOfferAnswerOptions options_reject_audio = options_no_bundle;
-  options_reject_audio.offer_to_receive_audio = 0;
-  options_reject_audio.offer_to_receive_video =
-      RTCOfferAnswerOptions::kMaxOfferToReceiveMedia;
-
-  auto caller = CreatePeerConnection();
-  caller->AddAudioTrack("a");
-  caller->AddVideoTrack("v");
-  auto callee = CreatePeerConnection();
-
-  // Caller initially offers to send/recv audio and video.
-  ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
-  // Callee accepts the video as recv only but rejects the audio.
-  ASSERT_TRUE(caller->SetRemoteDescription(
-      callee->CreateAnswerAndSetAsLocal(options_reject_audio)));
-
-  auto caller_voice = caller->media_engine()->GetVoiceSendChannel(0);
-  EXPECT_FALSE(caller_voice);
-  auto caller_video_send = caller->media_engine()->GetVideoSendChannel(0);
-  auto caller_video_receive = caller->media_engine()->GetVideoReceiveChannel(0);
-  ASSERT_TRUE(caller_video_send && caller_video_receive);
-  EXPECT_EQ(0u, caller_video_receive->recv_streams().size());
-  EXPECT_EQ(1u, caller_video_send->send_streams().size());
-
-  // Callee adds its own audio/video stream and offers to receive audio/video
-  // too.
-  auto callee_audio_track = callee->AddAudioTrack("a");
-  callee->AddVideoTrack("v");
-  ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
-  ASSERT_TRUE(caller->SetRemoteDescription(
-      callee->CreateAnswerAndSetAsLocal(options_no_bundle)));
-
-  auto callee_voice_send = callee->media_engine()->GetVoiceSendChannel(0);
-  auto callee_voice_receive = callee->media_engine()->GetVoiceReceiveChannel(0);
-  ASSERT_TRUE(callee_voice_send && callee_voice_receive);
-  EXPECT_EQ(1u, callee_voice_receive->recv_streams().size());
-  EXPECT_EQ(1u, callee_voice_send->send_streams().size());
-  auto callee_video_send = callee->media_engine()->GetVideoSendChannel(0);
-  auto callee_video_receive = callee->media_engine()->GetVideoReceiveChannel(0);
-  ASSERT_TRUE(callee_video_send && callee_video_receive);
-  EXPECT_EQ(1u, callee_video_receive->recv_streams().size());
-  EXPECT_EQ(1u, callee_video_send->send_streams().size());
-
-  // Callee removes audio but keeps video and rejects the audio once again.
-  callee->pc()->RemoveTrackOrError(callee_audio_track);
-  ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
-  ASSERT_TRUE(
-      callee->SetLocalDescription(callee->CreateAnswer(options_reject_audio)));
-
-  auto callee_voice = callee->media_engine()->GetVoiceReceiveChannel(0);
-  EXPECT_FALSE(callee_voice);
-  callee_video_send = callee->media_engine()->GetVideoSendChannel(0);
-  callee_video_receive = callee->media_engine()->GetVideoReceiveChannel(0);
-  ASSERT_TRUE(callee_video_send && callee_video_receive);
-  EXPECT_EQ(1u, callee_video_receive->recv_streams().size());
-  EXPECT_EQ(1u, callee_video_send->send_streams().size());
-}
-
 // Tests that if the underlying video encoder fails to be initialized (signaled
 // by failing to set send codecs), the PeerConnection signals the error to the
 // client.
-TEST_P(PeerConnectionMediaTest, MediaEngineErrorPropagatedToClients) {
+TEST_F(PeerConnectionMediaTestUnifiedPlan,
+       MediaEngineErrorPropagatedToClients) {
   auto caller = CreatePeerConnectionWithAudioVideo();
   auto callee = CreatePeerConnectionWithAudioVideo();
 
   ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
 
-  auto video_channel = caller->media_engine()->GetVideoSendChannel(0);
+  auto video_channel =
+      VideoMediaSendChannel(caller->pc()->GetTransceivers()[1]);
   video_channel->set_fail_set_send_codecs(true);
 
   std::string error;
@@ -1255,14 +1145,15 @@ TEST_P(PeerConnectionMediaTest, MediaEngineErrorPropagatedToClients) {
 // Tests that if the underlying video encoder fails once then subsequent
 // attempts at setting the local/remote description will also fail, even if
 // SetSendCodecs no longer fails.
-TEST_P(PeerConnectionMediaTest,
+TEST_F(PeerConnectionMediaTestUnifiedPlan,
        FailToApplyDescriptionIfVideoEncoderHasEverFailed) {
   auto caller = CreatePeerConnectionWithAudioVideo();
   auto callee = CreatePeerConnectionWithAudioVideo();
 
   ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
 
-  auto video_channel = caller->media_engine()->GetVideoSendChannel(0);
+  auto video_channel =
+      VideoMediaSendChannel(caller->pc()->GetTransceivers()[1]);
   video_channel->set_fail_set_send_codecs(true);
 
   EXPECT_FALSE(
diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc
index 15529827a7..f659ecf2ef 100644
--- a/pc/rtp_sender_receiver_unittest.cc
+++ b/pc/rtp_sender_receiver_unittest.cc
@@ -118,39 +118,18 @@ class RtpSenderReceiverTest
 
     // Create the channels, discard the result; we get them later.
     // Fake media channels are owned by the media engine.
-    media_engine_->voice().CreateMediaChannel(
-        cricket::MediaChannel::Role::kSend, &fake_call_, cricket::MediaConfig(),
-        cricket::AudioOptions(), webrtc::CryptoOptions(),
-        webrtc::AudioCodecPairId::Create());
-    media_engine_->video().CreateMediaChannel(
-        cricket::MediaChannel::Role::kSend, &fake_call_, cricket::MediaConfig(),
-        cricket::VideoOptions(), webrtc::CryptoOptions(),
-        video_bitrate_allocator_factory_.get());
-    media_engine_->voice().CreateMediaChannel(
-        cricket::MediaChannel::Role::kReceive, &fake_call_,
-        cricket::MediaConfig(), cricket::AudioOptions(),
+    voice_media_send_channel_ = media_engine_->voice().CreateSendChannel(
+        &fake_call_, cricket::MediaConfig(), cricket::AudioOptions(),
         webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create());
-    media_engine_->video().CreateMediaChannel(
-        cricket::MediaChannel::Role::kReceive, &fake_call_,
-        cricket::MediaConfig(), cricket::VideoOptions(),
+    video_media_send_channel_ = media_engine_->video().CreateSendChannel(
+        &fake_call_, cricket::MediaConfig(), cricket::VideoOptions(),
         webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get());
-
-    voice_media_send_channel_ =
-        absl::WrapUnique(media_engine_->GetVoiceSendChannel(0));
-    video_media_send_channel_ =
-        absl::WrapUnique(media_engine_->GetVideoSendChannel(0));
-    voice_media_receive_channel_ =
-        absl::WrapUnique(media_engine_->GetVoiceReceiveChannel(0));
-    video_media_receive_channel_ =
-        absl::WrapUnique(media_engine_->GetVideoReceiveChannel(0));
-
-    RTC_CHECK(voice_media_send_channel());
-    RTC_CHECK(video_media_send_channel());
-    RTC_CHECK(voice_media_receive_channel());
-    RTC_CHECK(video_media_receive_channel());
-    // Create sender channel objects
-    voice_send_channel_ = voice_media_send_channel()->AsVoiceSendChannel();
-    video_send_channel_ = video_media_send_channel()->AsVideoSendChannel();
+    voice_media_receive_channel_ = media_engine_->voice().CreateReceiveChannel(
+        &fake_call_, cricket::MediaConfig(), cricket::AudioOptions(),
+        webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create());
+    video_media_receive_channel_ = media_engine_->video().CreateReceiveChannel(
+        &fake_call_, cricket::MediaConfig(), cricket::VideoOptions(),
+        webrtc::CryptoOptions());
 
     // Create streams for predefined SSRCs. Streams need to exist in order
     // for the senders and receievers to apply parameters to them.
@@ -225,7 +204,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_send_channel_);
+    audio_rtp_sender_->SetMediaChannel(voice_media_send_channel_.get());
     audio_rtp_sender_->SetSsrc(kAudioSsrc);
     VerifyVoiceChannelInput();
   }
@@ -233,8 +212,7 @@ class RtpSenderReceiverTest
   void CreateAudioRtpSenderWithNoTrack() {
     audio_rtp_sender_ =
         AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr, nullptr);
-    audio_rtp_sender_->SetMediaChannel(
-        voice_media_send_channel()->AsVoiceSendChannel());
+    audio_rtp_sender_->SetMediaChannel(voice_media_send_channel_.get());
   }
 
   void CreateVideoRtpSender(uint32_t ssrc) {
@@ -286,16 +264,14 @@ class RtpSenderReceiverTest
     ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_.get()));
     EXPECT_CALL(*set_streams_observer, OnSetStreams());
     video_rtp_sender_->SetStreams({local_stream_->id()});
-    video_rtp_sender_->SetMediaChannel(
-        video_media_send_channel()->AsVideoSendChannel());
+    video_rtp_sender_->SetMediaChannel(video_media_send_channel());
     video_rtp_sender_->SetSsrc(ssrc);
     VerifyVideoChannelInput(ssrc);
   }
   void CreateVideoRtpSenderWithNoTrack() {
     video_rtp_sender_ =
         VideoRtpSender::Create(worker_thread_, /*id=*/"", nullptr);
-    video_rtp_sender_->SetMediaChannel(
-        video_media_send_channel()->AsVideoSendChannel());
+    video_rtp_sender_->SetMediaChannel(video_media_send_channel());
   }
 
   void DestroyAudioRtpSender() {
@@ -313,8 +289,7 @@ class RtpSenderReceiverTest
     audio_rtp_receiver_ = rtc::make_ref_counted<AudioRtpReceiver>(
         rtc::Thread::Current(), kAudioTrackId, streams,
         /*is_unified_plan=*/true);
-    audio_rtp_receiver_->SetMediaChannel(
-        voice_media_receive_channel()->AsVoiceReceiveChannel());
+    audio_rtp_receiver_->SetMediaChannel(voice_media_receive_channel());
     audio_rtp_receiver_->SetupMediaChannel(kAudioSsrc);
     audio_track_ = audio_rtp_receiver_->audio_track();
     VerifyVoiceChannelOutput();
@@ -324,8 +299,7 @@ class RtpSenderReceiverTest
       std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams = {}) {
     video_rtp_receiver_ = rtc::make_ref_counted<VideoRtpReceiver>(
         rtc::Thread::Current(), kVideoTrackId, streams);
-    video_rtp_receiver_->SetMediaChannel(
-        video_media_receive_channel()->AsVideoReceiveChannel());
+    video_rtp_receiver_->SetMediaChannel(video_media_receive_channel());
     video_rtp_receiver_->SetupMediaChannel(kVideoSsrc);
     video_track_ = video_rtp_receiver_->video_track();
     VerifyVideoChannelOutput();
@@ -345,8 +319,7 @@ class RtpSenderReceiverTest
 
     video_rtp_receiver_ = rtc::make_ref_counted<VideoRtpReceiver>(
         rtc::Thread::Current(), kVideoTrackId, streams);
-    video_rtp_receiver_->SetMediaChannel(
-        video_media_receive_channel()->AsVideoReceiveChannel());
+    video_rtp_receiver_->SetMediaChannel(video_media_receive_channel());
     video_rtp_receiver_->SetupMediaChannel(primary_ssrc);
     video_track_ = video_rtp_receiver_->video_track();
   }
@@ -381,7 +354,7 @@ class RtpSenderReceiverTest
 
   void VerifyVideoChannelInput(uint32_t ssrc) {
     // Verify that the media channel has a video source,
-    EXPECT_TRUE(video_media_send_channel_->HasSource(ssrc));
+    EXPECT_TRUE(video_media_send_channel()->HasSource(ssrc));
   }
 
   void VerifyVoiceChannelNoInput() { VerifyVoiceChannelNoInput(kAudioSsrc); }
@@ -395,7 +368,7 @@ class RtpSenderReceiverTest
 
   void VerifyVideoChannelNoInput(uint32_t ssrc) {
     // Verify that the media channel's source is reset.
-    EXPECT_FALSE(video_media_receive_channel_->HasSource(ssrc));
+    EXPECT_FALSE(video_media_receive_channel()->HasSource(ssrc));
   }
 
   void VerifyVoiceChannelOutput() {
@@ -408,7 +381,7 @@ class RtpSenderReceiverTest
 
   void VerifyVideoChannelOutput() {
     // Verify that the media channel has a sink.
-    EXPECT_TRUE(video_media_receive_channel_->HasSink(kVideoSsrc));
+    EXPECT_TRUE(video_media_receive_channel()->HasSink(kVideoSsrc));
   }
 
   void VerifyVoiceChannelNoOutput() {
@@ -421,7 +394,7 @@ class RtpSenderReceiverTest
 
   void VerifyVideoChannelNoOutput() {
     // Verify that the media channel's sink is reset.
-    EXPECT_FALSE(video_media_receive_channel_->HasSink(kVideoSsrc));
+    EXPECT_FALSE(video_media_receive_channel()->HasSink(kVideoSsrc));
   }
 
   // Verifies that the encoding layers contain the specified RIDs.
@@ -522,17 +495,21 @@ class RtpSenderReceiverTest
   }
 
  protected:
-  cricket::FakeVideoMediaChannel* video_media_send_channel() {
-    return video_media_send_channel_.get();
+  cricket::FakeVideoMediaSendChannel* video_media_send_channel() {
+    return static_cast<cricket::FakeVideoMediaSendChannel*>(
+        video_media_send_channel_.get());
   }
-  cricket::FakeVoiceMediaChannel* voice_media_send_channel() {
-    return voice_media_send_channel_.get();
+  cricket::FakeVoiceMediaSendChannel* voice_media_send_channel() {
+    return static_cast<cricket::FakeVoiceMediaSendChannel*>(
+        voice_media_send_channel_.get());
   }
-  cricket::FakeVideoMediaChannel* video_media_receive_channel() {
-    return video_media_receive_channel_.get();
+  cricket::FakeVideoMediaReceiveChannel* video_media_receive_channel() {
+    return static_cast<cricket::FakeVideoMediaReceiveChannel*>(
+        video_media_receive_channel_.get());
   }
-  cricket::FakeVoiceMediaChannel* voice_media_receive_channel() {
-    return voice_media_receive_channel_.get();
+  cricket::FakeVoiceMediaReceiveChannel* voice_media_receive_channel() {
+    return static_cast<cricket::FakeVoiceMediaReceiveChannel*>(
+        voice_media_receive_channel_.get());
   }
 
   test::RunLoop run_loop_;
@@ -548,12 +525,14 @@ class RtpSenderReceiverTest
   std::unique_ptr<cricket::FakeMediaEngine> media_engine_;
   rtc::UniqueRandomIdGenerator ssrc_generator_;
   cricket::FakeCall fake_call_;
-  std::unique_ptr<cricket::FakeVoiceMediaChannel> voice_media_send_channel_;
-  std::unique_ptr<cricket::FakeVideoMediaChannel> video_media_send_channel_;
-  std::unique_ptr<cricket::FakeVoiceMediaChannel> voice_media_receive_channel_;
-  std::unique_ptr<cricket::FakeVideoMediaChannel> video_media_receive_channel_;
-  cricket::VoiceMediaSendChannelInterface* voice_send_channel_;
-  cricket::VideoMediaSendChannelInterface* video_send_channel_;
+  std::unique_ptr<cricket::VoiceMediaSendChannelInterface>
+      voice_media_send_channel_;
+  std::unique_ptr<cricket::VideoMediaSendChannelInterface>
+      video_media_send_channel_;
+  std::unique_ptr<cricket::VoiceMediaReceiveChannelInterface>
+      voice_media_receive_channel_;
+  std::unique_ptr<cricket::VideoMediaReceiveChannelInterface>
+      video_media_receive_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/rtp_transceiver.cc b/pc/rtp_transceiver.cc
index d1bf578db8..8948b7c968 100644
--- a/pc/rtp_transceiver.cc
+++ b/pc/rtp_transceiver.cc
@@ -25,6 +25,7 @@
 #include "api/rtp_parameters.h"
 #include "api/sequence_checker.h"
 #include "media/base/codec.h"
+#include "media/base/media_channel.h"
 #include "media/base/media_channel_impl.h"
 #include "media/base/media_constants.h"
 #include "media/base/media_engine.h"
@@ -219,18 +220,19 @@ RTCError RtpTransceiver::CreateChannel(
       AudioCodecPairId codec_pair_id = AudioCodecPairId::Create();
 
       if (use_split_media_channel) {
-        std::unique_ptr<cricket::VoiceMediaChannel> media_send_channel =
-            absl::WrapUnique(media_engine()->voice().CreateMediaChannel(
-                cricket::MediaChannel::Role::kSend, call_ptr, media_config,
-                audio_options, crypto_options, codec_pair_id));
+        std::unique_ptr<cricket::VoiceMediaSendChannelInterface>
+            media_send_channel = media_engine()->voice().CreateSendChannel(
+                call_ptr, media_config, audio_options, crypto_options,
+                codec_pair_id);
         if (!media_send_channel) {
           // TODO(bugs.webrtc.org/14912): Consider CHECK or reporting failure
           return;
         }
-        std::unique_ptr<cricket::VoiceMediaChannel> media_receive_channel =
-            absl::WrapUnique(media_engine()->voice().CreateMediaChannel(
-                cricket::MediaChannel::Role::kReceive, call_ptr, media_config,
-                audio_options, crypto_options, codec_pair_id));
+        std::unique_ptr<cricket::VoiceMediaReceiveChannelInterface>
+            media_receive_channel =
+                media_engine()->voice().CreateReceiveChannel(
+                    call_ptr, media_config, audio_options, crypto_options,
+                    codec_pair_id);
         if (!media_receive_channel) {
           return;
         }
@@ -272,20 +274,18 @@ RTCError RtpTransceiver::CreateChannel(
       RTC_DCHECK_RUN_ON(context()->worker_thread());
 
       if (use_split_media_channel) {
-        std::unique_ptr<cricket::VideoMediaChannel> media_send_channel =
-            absl::WrapUnique(media_engine()->video().CreateMediaChannel(
-                cricket::MediaChannel::Role::kSend, call_ptr, media_config,
-                video_options, crypto_options,
-                video_bitrate_allocator_factory));
+        std::unique_ptr<cricket::VideoMediaSendChannelInterface>
+            media_send_channel = media_engine()->video().CreateSendChannel(
+                call_ptr, media_config, video_options, crypto_options,
+                video_bitrate_allocator_factory);
         if (!media_send_channel) {
           return;
         }
 
-        std::unique_ptr<cricket::VideoMediaChannel> media_receive_channel =
-            absl::WrapUnique(media_engine()->video().CreateMediaChannel(
-                cricket::MediaChannel::Role::kReceive, call_ptr, media_config,
-                video_options, crypto_options,
-                video_bitrate_allocator_factory));
+        std::unique_ptr<cricket::VideoMediaReceiveChannelInterface>
+            media_receive_channel =
+                media_engine()->video().CreateReceiveChannel(
+                    call_ptr, media_config, video_options, crypto_options);
         if (!media_receive_channel) {
           return;
         }
diff --git a/pc/test/fake_peer_connection_for_stats.h b/pc/test/fake_peer_connection_for_stats.h
index 79be6a0403..7302182912 100644
--- a/pc/test/fake_peer_connection_for_stats.h
+++ b/pc/test/fake_peer_connection_for_stats.h
@@ -19,6 +19,7 @@
 #include <vector>
 
 #include "media/base/fake_media_engine.h"
+#include "media/base/media_channel.h"
 #include "pc/channel.h"
 #include "pc/stream_collection.h"
 #include "pc/test/fake_data_channel_controller.h"
@@ -27,89 +28,49 @@
 namespace webrtc {
 
 // Fake VoiceMediaChannel where the result of GetStats can be configured.
-class FakeVoiceMediaChannelForStats : public cricket::FakeVoiceMediaChannel {
+class FakeVoiceMediaSendChannelForStats
+    : public cricket::FakeVoiceMediaSendChannel {
  public:
-  explicit FakeVoiceMediaChannelForStats(MediaChannel::Role role,
-                                         TaskQueueBase* network_thread)
-      : cricket::FakeVoiceMediaChannel(role,
-                                       nullptr,
-                                       cricket::AudioOptions(),
-                                       network_thread) {}
+  explicit FakeVoiceMediaSendChannelForStats(TaskQueueBase* network_thread)
+      : cricket::FakeVoiceMediaSendChannel(cricket::AudioOptions(),
+                                           network_thread) {}
 
   void SetStats(const cricket::VoiceMediaInfo& voice_info) {
     send_stats_ = cricket::VoiceMediaSendInfo();
     send_stats_->senders = voice_info.senders;
     send_stats_->send_codecs = voice_info.send_codecs;
-    receive_stats_ = cricket::VoiceMediaReceiveInfo();
-    receive_stats_->receivers = voice_info.receivers;
-    receive_stats_->receive_codecs = voice_info.receive_codecs;
-    receive_stats_->device_underrun_count = voice_info.device_underrun_count;
   }
 
   // VoiceMediaChannel overrides.
-  bool GetSendStats(cricket::VoiceMediaSendInfo* info) override {
-    RTC_DCHECK(role() == MediaChannel::Role::kSend);
+  bool GetStats(cricket::VoiceMediaSendInfo* info) override {
     if (send_stats_) {
       *info = *send_stats_;
       return true;
     }
     return false;
   }
-  bool GetReceiveStats(cricket::VoiceMediaReceiveInfo* info,
-                       bool get_and_clear_legacy_stats) override {
-    RTC_DCHECK(role() == MediaChannel::Role::kReceive);
-    if (receive_stats_) {
-      *info = *receive_stats_;
-      return true;
-    }
-    return false;
-  }
 
  private:
   absl::optional<cricket::VoiceMediaSendInfo> send_stats_;
-  absl::optional<cricket::VoiceMediaReceiveInfo> receive_stats_;
 };
 
-// Fake VideoMediaChannel where the result of GetStats can be configured.
-class FakeVideoMediaChannelForStats : public cricket::FakeVideoMediaChannel {
+class FakeVoiceMediaReceiveChannelForStats
+    : public cricket::FakeVoiceMediaReceiveChannel {
  public:
-  explicit FakeVideoMediaChannelForStats(cricket::MediaChannel::Role role,
-                                         TaskQueueBase* network_thread)
-      : cricket::FakeVideoMediaChannel(role,
-                                       nullptr,
-                                       cricket::VideoOptions(),
-                                       network_thread) {}
+  explicit FakeVoiceMediaReceiveChannelForStats(TaskQueueBase* network_thread)
+      : cricket::FakeVoiceMediaReceiveChannel(cricket::AudioOptions(),
+                                              network_thread) {}
 
-  void SetStats(const cricket::VideoMediaInfo& video_info) {
-    switch (role()) {
-      case MediaChannel::Role::kSend:
-        send_stats_ = cricket::VideoMediaSendInfo();
-        send_stats_->senders = video_info.senders;
-        send_stats_->aggregated_senders = video_info.aggregated_senders;
-        send_stats_->send_codecs = video_info.send_codecs;
-        break;
-      case MediaChannel::Role::kReceive:
-        receive_stats_ = cricket::VideoMediaReceiveInfo();
-        receive_stats_->receivers = video_info.receivers;
-        receive_stats_->receive_codecs = video_info.receive_codecs;
-        break;
-      default:
-        RTC_CHECK_NOTREACHED();
-    }
+  void SetStats(const cricket::VoiceMediaInfo& voice_info) {
+    receive_stats_ = cricket::VoiceMediaReceiveInfo();
+    receive_stats_->receivers = voice_info.receivers;
+    receive_stats_->receive_codecs = voice_info.receive_codecs;
+    receive_stats_->device_underrun_count = voice_info.device_underrun_count;
   }
 
-  // VideoMediaChannel overrides.
-  bool GetSendStats(cricket::VideoMediaSendInfo* info) override {
-    RTC_DCHECK(role() == MediaChannel::Role::kSend);
-
-    if (send_stats_) {
-      *info = *send_stats_;
-      return true;
-    }
-    return false;
-  }
-  bool GetReceiveStats(cricket::VideoMediaReceiveInfo* info) override {
-    RTC_DCHECK(role() == MediaChannel::Role::kReceive);
+  // VoiceMediaChannel overrides.
+  bool GetStats(cricket::VoiceMediaReceiveInfo* info,
+                bool get_and_clear_legacy_stats) override {
     if (receive_stats_) {
       *info = *receive_stats_;
       return true;
@@ -117,8 +78,61 @@ class FakeVideoMediaChannelForStats : public cricket::FakeVideoMediaChannel {
     return false;
   }
 
+ private:
+  absl::optional<cricket::VoiceMediaReceiveInfo> receive_stats_;
+};
+
+// Fake VideoMediaChannel where the result of GetStats can be configured.
+class FakeVideoMediaSendChannelForStats
+    : public cricket::FakeVideoMediaSendChannel {
+ public:
+  explicit FakeVideoMediaSendChannelForStats(TaskQueueBase* network_thread)
+      : cricket::FakeVideoMediaSendChannel(cricket::VideoOptions(),
+                                           network_thread) {}
+
+  void SetStats(const cricket::VideoMediaInfo& video_info) {
+    send_stats_ = cricket::VideoMediaSendInfo();
+    send_stats_->senders = video_info.senders;
+    send_stats_->aggregated_senders = video_info.aggregated_senders;
+    send_stats_->send_codecs = video_info.send_codecs;
+  }
+
+  // VideoMediaChannel overrides.
+  bool GetStats(cricket::VideoMediaSendInfo* info) override {
+    if (send_stats_) {
+      *info = *send_stats_;
+      return true;
+    }
+    return false;
+  }
+
  private:
   absl::optional<cricket::VideoMediaSendInfo> send_stats_;
+};
+
+class FakeVideoMediaReceiveChannelForStats
+    : public cricket::FakeVideoMediaReceiveChannel {
+ public:
+  explicit FakeVideoMediaReceiveChannelForStats(TaskQueueBase* network_thread)
+      : cricket::FakeVideoMediaReceiveChannel(cricket::VideoOptions(),
+                                              network_thread) {}
+
+  void SetStats(const cricket::VideoMediaInfo& video_info) {
+    receive_stats_ = cricket::VideoMediaReceiveInfo();
+    receive_stats_->receivers = video_info.receivers;
+    receive_stats_->receive_codecs = video_info.receive_codecs;
+  }
+
+  // VideoMediaChannel overrides.
+  bool GetStats(cricket::VideoMediaReceiveInfo* info) override {
+    if (receive_stats_) {
+      *info = *receive_stats_;
+      return true;
+    }
+    return false;
+  }
+
+ private:
   absl::optional<cricket::VideoMediaReceiveInfo> receive_stats_;
 };
 
@@ -131,8 +145,9 @@ class VoiceChannelForTesting : public cricket::VoiceChannel {
       rtc::Thread* worker_thread,
       rtc::Thread* network_thread,
       rtc::Thread* signaling_thread,
-      std::unique_ptr<cricket::VoiceMediaChannel> send_channel,
-      std::unique_ptr<cricket::VoiceMediaChannel> receive_channel,
+      std::unique_ptr<cricket::VoiceMediaSendChannelInterface> send_channel,
+      std::unique_ptr<cricket::VoiceMediaReceiveChannelInterface>
+          receive_channel,
       const std::string& content_name,
       bool srtp_required,
       webrtc::CryptoOptions crypto_options,
@@ -163,8 +178,9 @@ class VideoChannelForTesting : public cricket::VideoChannel {
       rtc::Thread* worker_thread,
       rtc::Thread* network_thread,
       rtc::Thread* signaling_thread,
-      std::unique_ptr<cricket::VideoMediaChannel> send_channel,
-      std::unique_ptr<cricket::VideoMediaChannel> receive_channel,
+      std::unique_ptr<cricket::VideoMediaSendChannelInterface> send_channel,
+      std::unique_ptr<cricket::VideoMediaReceiveChannelInterface>
+          receive_channel,
       const std::string& content_name,
       bool srtp_required,
       webrtc::CryptoOptions crypto_options,
@@ -266,17 +282,16 @@ class FakePeerConnectionForStats : public FakePeerConnectionBase {
         ->RemoveReceiver(receiver.get());
   }
 
-  std::pair<FakeVoiceMediaChannelForStats*, FakeVoiceMediaChannelForStats*>
+  std::pair<FakeVoiceMediaSendChannelForStats*,
+            FakeVoiceMediaReceiveChannelForStats*>
   AddVoiceChannel(
       const std::string& mid,
       const std::string& transport_name,
       cricket::VoiceMediaInfo initial_stats = cricket::VoiceMediaInfo()) {
     auto voice_media_send_channel =
-        std::make_unique<FakeVoiceMediaChannelForStats>(
-            cricket::MediaChannel::Role::kSend, network_thread_);
+        std::make_unique<FakeVoiceMediaSendChannelForStats>(network_thread_);
     auto voice_media_receive_channel =
-        std::make_unique<FakeVoiceMediaChannelForStats>(
-            cricket::MediaChannel::Role::kReceive, network_thread_);
+        std::make_unique<FakeVoiceMediaReceiveChannelForStats>(network_thread_);
     auto* voice_media_send_channel_ptr = voice_media_send_channel.get();
     auto* voice_media_receive_channel_ptr = voice_media_receive_channel.get();
     auto voice_channel = std::make_unique<VoiceChannelForTesting>(
@@ -301,17 +316,16 @@ class FakePeerConnectionForStats : public FakePeerConnectionBase {
                           voice_media_receive_channel_ptr);
   }
 
-  std::pair<FakeVideoMediaChannelForStats*, FakeVideoMediaChannelForStats*>
+  std::pair<FakeVideoMediaSendChannelForStats*,
+            FakeVideoMediaReceiveChannelForStats*>
   AddVideoChannel(
       const std::string& mid,
       const std::string& transport_name,
       cricket::VideoMediaInfo initial_stats = cricket::VideoMediaInfo()) {
     auto video_media_send_channel =
-        std::make_unique<FakeVideoMediaChannelForStats>(
-            cricket::MediaChannel::Role::kSend, network_thread_);
+        std::make_unique<FakeVideoMediaSendChannelForStats>(network_thread_);
     auto video_media_receive_channel =
-        std::make_unique<FakeVideoMediaChannelForStats>(
-            cricket::MediaChannel::Role::kReceive, network_thread_);
+        std::make_unique<FakeVideoMediaReceiveChannelForStats>(network_thread_);
     auto video_media_send_channel_ptr = video_media_send_channel.get();
     auto video_media_receive_channel_ptr = video_media_receive_channel.get();
     auto video_channel = std::make_unique<VideoChannelForTesting>(
diff --git a/pc/video_rtp_receiver_unittest.cc b/pc/video_rtp_receiver_unittest.cc
index 5efd6df471..5ff736084f 100644
--- a/pc/video_rtp_receiver_unittest.cc
+++ b/pc/video_rtp_receiver_unittest.cc
@@ -17,6 +17,7 @@
 #include "api/video/recordable_encoded_frame.h"
 #include "api/video/test/mock_recordable_encoded_frame.h"
 #include "media/base/fake_media_engine.h"
+#include "media/base/media_channel.h"
 #include "rtc_base/task_queue_for_test.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
@@ -34,16 +35,25 @@ namespace {
 
 class VideoRtpReceiverTest : public testing::Test {
  protected:
-  class MockVideoMediaChannel : public cricket::FakeVideoMediaChannel {
+  class MockVideoMediaSendChannel : public cricket::FakeVideoMediaSendChannel {
    public:
-    MockVideoMediaChannel(
-        cricket::FakeVideoEngine* engine,
+    MockVideoMediaSendChannel(
         const cricket::VideoOptions& options,
         TaskQueueBase* network_thread = rtc::Thread::Current())
-        : FakeVideoMediaChannel(cricket::MediaChannel::Role::kBoth,
-                                engine,
-                                options,
-                                network_thread) {}
+        : FakeVideoMediaSendChannel(options, network_thread) {}
+    MOCK_METHOD(void,
+                GenerateSendKeyFrame,
+                (uint32_t, const std::vector<std::string>&),
+                (override));
+  };
+
+  class MockVideoMediaReceiveChannel
+      : public cricket::FakeVideoMediaReceiveChannel {
+   public:
+    MockVideoMediaReceiveChannel(
+        const cricket::VideoOptions& options,
+        TaskQueueBase* network_thread = rtc::Thread::Current())
+        : FakeVideoMediaReceiveChannel(options, network_thread) {}
     MOCK_METHOD(void,
                 SetRecordableEncodedFrameCallback,
                 (uint32_t, std::function<void(const RecordableEncodedFrame&)>),
@@ -53,10 +63,6 @@ class VideoRtpReceiverTest : public testing::Test {
                 (uint32_t),
                 (override));
     MOCK_METHOD(void, RequestRecvKeyFrame, (uint32_t), (override));
-    MOCK_METHOD(void,
-                GenerateSendKeyFrame,
-                (uint32_t, const std::vector<std::string>&),
-                (override));
   };
 
   class MockVideoSink : public rtc::VideoSinkInterface<RecordableEncodedFrame> {
@@ -66,7 +72,7 @@ class VideoRtpReceiverTest : public testing::Test {
 
   VideoRtpReceiverTest()
       : worker_thread_(rtc::Thread::Create()),
-        channel_(nullptr, cricket::VideoOptions()),
+        channel_(cricket::VideoOptions()),
         receiver_(rtc::make_ref_counted<VideoRtpReceiver>(
             worker_thread_.get(),
             std::string("receiver"),
@@ -83,7 +89,7 @@ class VideoRtpReceiverTest : public testing::Test {
     SetMediaChannel(nullptr);
   }
 
-  void SetMediaChannel(cricket::MediaChannel* media_channel) {
+  void SetMediaChannel(cricket::MediaReceiveChannelInterface* media_channel) {
     SendTask(worker_thread_.get(),
              [&]() { receiver_->SetMediaChannel(media_channel); });
   }
@@ -94,7 +100,7 @@ class VideoRtpReceiverTest : public testing::Test {
 
   rtc::AutoThread main_thread_;
   std::unique_ptr<rtc::Thread> worker_thread_;
-  NiceMock<MockVideoMediaChannel> channel_;
+  NiceMock<MockVideoMediaReceiveChannel> channel_;
   rtc::scoped_refptr<VideoRtpReceiver> receiver_;
 };
 
@@ -111,7 +117,7 @@ TEST_F(VideoRtpReceiverTest,
        GenerateKeyFrameOnChannelSwitchUnlessGenerateKeyframeCalled) {
   // A channel switch without previous call to GenerateKeyFrame shouldn't
   // cause a call to happen on the new channel.
-  MockVideoMediaChannel channel2(nullptr, cricket::VideoOptions());
+  MockVideoMediaReceiveChannel channel2{cricket::VideoOptions()};
   EXPECT_CALL(channel_, RequestRecvKeyFrame).Times(0);
   EXPECT_CALL(channel2, RequestRecvKeyFrame).Times(0);
   SetMediaChannel(&channel2);
@@ -121,12 +127,12 @@ TEST_F(VideoRtpReceiverTest,
   // re-generate it as we don't know if it was eventually received
   EXPECT_CALL(channel2, RequestRecvKeyFrame).Times(1);
   Source()->GenerateKeyFrame();
-  MockVideoMediaChannel channel3(nullptr, cricket::VideoOptions());
+  MockVideoMediaReceiveChannel channel3{cricket::VideoOptions()};
   EXPECT_CALL(channel3, RequestRecvKeyFrame);
   SetMediaChannel(&channel3);
 
   // Switching to a new channel should now not cause calls to GenerateKeyFrame.
-  StrictMock<MockVideoMediaChannel> channel4(nullptr, cricket::VideoOptions());
+  StrictMock<MockVideoMediaReceiveChannel> channel4{cricket::VideoOptions()};
   SetMediaChannel(&channel4);
 
   // We must call SetMediaChannel(nullptr) here since the mock media channels
@@ -154,7 +160,7 @@ TEST_F(VideoRtpReceiverTest, DisablesEnablesEncodedOutputOnChannelSwitch) {
   EXPECT_CALL(channel_, ClearRecordableEncodedFrameCallback);
   MockVideoSink sink;
   Source()->AddEncodedSink(&sink);
-  MockVideoMediaChannel channel2(nullptr, cricket::VideoOptions());
+  MockVideoMediaReceiveChannel channel2{cricket::VideoOptions()};
   EXPECT_CALL(channel2, SetRecordableEncodedFrameCallback);
   SetMediaChannel(&channel2);
   Mock::VerifyAndClearExpectations(&channel2);
@@ -163,7 +169,7 @@ TEST_F(VideoRtpReceiverTest, DisablesEnablesEncodedOutputOnChannelSwitch) {
   // to NOT set the callback again.
   EXPECT_CALL(channel2, ClearRecordableEncodedFrameCallback);
   Source()->RemoveEncodedSink(&sink);
-  StrictMock<MockVideoMediaChannel> channel3(nullptr, cricket::VideoOptions());
+  StrictMock<MockVideoMediaReceiveChannel> channel3{cricket::VideoOptions()};
   SetMediaChannel(&channel3);
 
   // We must call SetMediaChannel(nullptr) here since the mock media channels