diff --git a/audio/test/audio_bwe_integration_test.cc b/audio/test/audio_bwe_integration_test.cc
index 50a4b6759c..fd68cbd627 100644
--- a/audio/test/audio_bwe_integration_test.cc
+++ b/audio/test/audio_bwe_integration_test.cc
@@ -58,27 +58,6 @@ void AudioBweTest::OnFakeAudioDevicesCreated(
   send_audio_device_ = send_audio_device;
 }
 
-std::unique_ptr<test::PacketTransport> AudioBweTest::CreateSendTransport(
-    TaskQueueBase* task_queue,
-    Call* sender_call) {
-  return std::make_unique<test::PacketTransport>(
-      task_queue, sender_call, this, test::PacketTransport::kSender,
-      test::CallTest::payload_type_map_,
-      std::make_unique<FakeNetworkPipe>(
-          Clock::GetRealTimeClock(),
-          std::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
-}
-
-std::unique_ptr<test::PacketTransport> AudioBweTest::CreateReceiveTransport(
-    TaskQueueBase* task_queue) {
-  return std::make_unique<test::PacketTransport>(
-      task_queue, nullptr, this, test::PacketTransport::kReceiver,
-      test::CallTest::payload_type_map_,
-      std::make_unique<FakeNetworkPipe>(
-          Clock::GetRealTimeClock(),
-          std::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
-}
-
 void AudioBweTest::PerformTest() {
   send_audio_device_->WaitForRecordingEnd();
   SleepMs(GetNetworkPipeConfig().queue_delay_ms + kExtraProcessTimeMs);
diff --git a/audio/test/audio_bwe_integration_test.h b/audio/test/audio_bwe_integration_test.h
index 613efcc1dd..132ab0a3a5 100644
--- a/audio/test/audio_bwe_integration_test.h
+++ b/audio/test/audio_bwe_integration_test.h
@@ -39,12 +39,6 @@ class AudioBweTest : public test::EndToEndTest {
       TestAudioDeviceModule* send_audio_device,
       TestAudioDeviceModule* recv_audio_device) override;
 
-  std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      TaskQueueBase* task_queue,
-      Call* sender_call) override;
-  std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-      TaskQueueBase* task_queue) override;
-
   void PerformTest() override;
 
  private:
diff --git a/audio/test/audio_end_to_end_test.cc b/audio/test/audio_end_to_end_test.cc
index de9cf7d56f..b7dfdb89f6 100644
--- a/audio/test/audio_end_to_end_test.cc
+++ b/audio/test/audio_end_to_end_test.cc
@@ -31,10 +31,6 @@ constexpr int kSampleRate = 48000;
 AudioEndToEndTest::AudioEndToEndTest()
     : EndToEndTest(CallTest::kDefaultTimeout) {}
 
-BuiltInNetworkBehaviorConfig AudioEndToEndTest::GetNetworkPipeConfig() const {
-  return BuiltInNetworkBehaviorConfig();
-}
-
 size_t AudioEndToEndTest::GetNumVideoStreams() const {
   return 0;
 }
@@ -63,27 +59,6 @@ void AudioEndToEndTest::OnFakeAudioDevicesCreated(
   send_audio_device_ = send_audio_device;
 }
 
-std::unique_ptr<test::PacketTransport> AudioEndToEndTest::CreateSendTransport(
-    TaskQueueBase* task_queue,
-    Call* sender_call) {
-  return std::make_unique<test::PacketTransport>(
-      task_queue, sender_call, this, test::PacketTransport::kSender,
-      test::CallTest::payload_type_map_,
-      std::make_unique<FakeNetworkPipe>(
-          Clock::GetRealTimeClock(),
-          std::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
-}
-
-std::unique_ptr<test::PacketTransport>
-AudioEndToEndTest::CreateReceiveTransport(TaskQueueBase* task_queue) {
-  return std::make_unique<test::PacketTransport>(
-      task_queue, nullptr, this, test::PacketTransport::kReceiver,
-      test::CallTest::payload_type_map_,
-      std::make_unique<FakeNetworkPipe>(
-          Clock::GetRealTimeClock(),
-          std::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
-}
-
 void AudioEndToEndTest::ModifyAudioConfigs(
     AudioSendStream::Config* send_config,
     std::vector<AudioReceiveStreamInterface::Config>* receive_configs) {
@@ -110,7 +85,7 @@ void AudioEndToEndTest::PerformTest() {
   // Wait until the input audio file is done...
   send_audio_device_->WaitForRecordingEnd();
   // and some extra time to account for network delay.
-  SleepMs(GetNetworkPipeConfig().queue_delay_ms + kExtraRecordTimeMs);
+  SleepMs(GetSendTransportConfig().queue_delay_ms + kExtraRecordTimeMs);
 }
 }  // namespace test
 }  // namespace webrtc
diff --git a/audio/test/audio_end_to_end_test.h b/audio/test/audio_end_to_end_test.h
index 6afa0baea3..607fe692be 100644
--- a/audio/test/audio_end_to_end_test.h
+++ b/audio/test/audio_end_to_end_test.h
@@ -32,8 +32,6 @@ class AudioEndToEndTest : public test::EndToEndTest {
     return receive_stream_;
   }
 
-  virtual BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const;
-
   size_t GetNumVideoStreams() const override;
   size_t GetNumAudioStreams() const override;
   size_t GetNumFlexfecStreams() const override;
@@ -45,12 +43,6 @@ class AudioEndToEndTest : public test::EndToEndTest {
       TestAudioDeviceModule* send_audio_device,
       TestAudioDeviceModule* recv_audio_device) override;
 
-  std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      TaskQueueBase* task_queue,
-      Call* sender_call) override;
-  std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-      TaskQueueBase* task_queue) override;
-
   void ModifyAudioConfigs(AudioSendStream::Config* send_config,
                           std::vector<AudioReceiveStreamInterface::Config>*
                               receive_configs) override;
diff --git a/audio/test/audio_stats_test.cc b/audio/test/audio_stats_test.cc
index c637bff94e..1c81432574 100644
--- a/audio/test/audio_stats_test.cc
+++ b/audio/test/audio_stats_test.cc
@@ -32,7 +32,7 @@ class NoLossTest : public AudioEndToEndTest {
 
   NoLossTest() = default;
 
-  BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const override {
+  BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
     BuiltInNetworkBehaviorConfig pipe_config;
     pipe_config.queue_delay_ms = kRttMs / 2;
     return pipe_config;
diff --git a/audio/test/low_bandwidth_audio_test.cc b/audio/test/low_bandwidth_audio_test.cc
index 948dcbc8f2..f385eb9dcc 100644
--- a/audio/test/low_bandwidth_audio_test.cc
+++ b/audio/test/low_bandwidth_audio_test.cc
@@ -84,7 +84,7 @@ class Mobile2GNetworkTest : public AudioQualityTest {
          {{"maxaveragebitrate", "6000"}, {"ptime", "60"}, {"stereo", "1"}}});
   }
 
-  BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const override {
+  BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
     BuiltInNetworkBehaviorConfig pipe_config;
     pipe_config.link_capacity_kbps = 12;
     pipe_config.queue_length_packets = 1500;
diff --git a/audio/test/nack_test.cc b/audio/test/nack_test.cc
index f383627dbe..c4bfe8306f 100644
--- a/audio/test/nack_test.cc
+++ b/audio/test/nack_test.cc
@@ -25,7 +25,7 @@ TEST_F(NackTest, ShouldNackInLossyNetwork) {
     const int64_t kLossPercent = 30;
     const int kNackHistoryMs = 1000;
 
-    BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const override {
+    BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
       BuiltInNetworkBehaviorConfig pipe_config;
       pipe_config.queue_delay_ms = kRttMs / 2;
       pipe_config.loss_percent = kLossPercent;
diff --git a/audio/test/non_sender_rtt_test.cc b/audio/test/non_sender_rtt_test.cc
index 07de99ac37..0c7dc6cbee 100644
--- a/audio/test/non_sender_rtt_test.cc
+++ b/audio/test/non_sender_rtt_test.cc
@@ -23,7 +23,7 @@ TEST_F(NonSenderRttTest, NonSenderRttStats) {
     const int kTestDurationMs = 10000;
     const int64_t kRttMs = 30;
 
-    BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const override {
+    BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
       BuiltInNetworkBehaviorConfig pipe_config;
       pipe_config.queue_delay_ms = kRttMs / 2;
       return pipe_config;
diff --git a/call/bitrate_estimator_tests.cc b/call/bitrate_estimator_tests.cc
index 5fb05e59d9..afa3136e0a 100644
--- a/call/bitrate_estimator_tests.cc
+++ b/call/bitrate_estimator_tests.cc
@@ -7,6 +7,7 @@
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
+#include <cstddef>
 #include <functional>
 #include <list>
 #include <memory>
@@ -15,7 +16,6 @@
 #include "absl/strings/string_view.h"
 #include "api/test/create_frame_generator.h"
 #include "call/call.h"
-#include "call/fake_network_pipe.h"
 #include "call/simulated_network.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/event.h"
@@ -24,7 +24,6 @@
 #include "rtc_base/task_queue_for_test.h"
 #include "rtc_base/thread_annotations.h"
 #include "test/call_test.h"
-#include "test/direct_transport.h"
 #include "test/encoder_settings.h"
 #include "test/fake_decoder.h"
 #include "test/fake_encoder.h"
@@ -113,20 +112,9 @@ class BitrateEstimatorTest : public test::CallTest {
     SendTask(task_queue(), [this]() {
       CreateCalls();
 
-      send_transport_.reset(new test::DirectTransport(
-          task_queue(),
-          std::make_unique<FakeNetworkPipe>(
-              Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
-                                             BuiltInNetworkBehaviorConfig())),
-          sender_call_.get(), payload_type_map_));
-      send_transport_->SetReceiver(receiver_call_->Receiver());
-      receive_transport_.reset(new test::DirectTransport(
-          task_queue(),
-          std::make_unique<FakeNetworkPipe>(
-              Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
-                                             BuiltInNetworkBehaviorConfig())),
-          receiver_call_.get(), payload_type_map_));
-      receive_transport_->SetReceiver(sender_call_->Receiver());
+      CreateSendTransport(BuiltInNetworkBehaviorConfig(), /*observer=*/nullptr);
+      CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
+                             /*observer=*/nullptr);
 
       VideoSendStream::Config video_send_config(send_transport_.get());
       video_send_config.rtp.ssrcs.push_back(kVideoSendSsrcs[0]);
@@ -160,10 +148,6 @@ class BitrateEstimatorTest : public test::CallTest {
         delete stream;
       }
       streams_.clear();
-
-      send_transport_.reset();
-      receive_transport_.reset();
-
       DestroyCalls();
     });
   }
@@ -245,8 +229,6 @@ class BitrateEstimatorTest : public test::CallTest {
   };
 
   LogObserver receiver_log_;
-  std::unique_ptr<test::DirectTransport> send_transport_;
-  std::unique_ptr<test::DirectTransport> receive_transport_;
   VideoReceiveStreamInterface::Config receive_config_;
   std::vector<Stream*> streams_;
 };
diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc
index 218ab7c9a8..a50f5ee605 100644
--- a/call/call_perf_tests.cc
+++ b/call/call_perf_tests.cc
@@ -243,23 +243,26 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
         test::PacketTransport::kSender, audio_pt_map,
         std::make_unique<FakeNetworkPipe>(
             Clock::GetRealTimeClock(),
-            std::make_unique<SimulatedNetwork>(audio_net_config)));
+            std::make_unique<SimulatedNetwork>(audio_net_config)),
+        GetRegisteredExtensions(), GetRegisteredExtensions());
     audio_send_transport->SetReceiver(receiver_call_->Receiver());
 
     video_send_transport = std::make_unique<test::PacketTransport>(
         task_queue(), sender_call_.get(), observer.get(),
         test::PacketTransport::kSender, video_pt_map,
-        std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
-                                          std::make_unique<SimulatedNetwork>(
-                                              BuiltInNetworkBehaviorConfig())));
+        std::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(),
+            std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
+        GetRegisteredExtensions(), GetRegisteredExtensions());
     video_send_transport->SetReceiver(receiver_call_->Receiver());
 
     receive_transport = std::make_unique<test::PacketTransport>(
         task_queue(), receiver_call_.get(), observer.get(),
         test::PacketTransport::kReceiver, payload_type_map_,
-        std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
-                                          std::make_unique<SimulatedNetwork>(
-                                              BuiltInNetworkBehaviorConfig())));
+        std::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(),
+            std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
+        GetRegisteredExtensions(), GetRegisteredExtensions());
     receive_transport->SetReceiver(sender_call_->Receiver());
 
     CreateSendConfig(1, 0, 0, video_send_transport.get());
@@ -412,25 +415,12 @@ void CallPerfTest::TestCaptureNtpTime(
           rtp_start_timestamp_(0) {}
 
    private:
-    std::unique_ptr<test::PacketTransport> CreateSendTransport(
-        TaskQueueBase* task_queue,
-        Call* sender_call) override {
-      return std::make_unique<test::PacketTransport>(
-          task_queue, sender_call, this, test::PacketTransport::kSender,
-          payload_type_map_,
-          std::make_unique<FakeNetworkPipe>(
-              Clock::GetRealTimeClock(),
-              std::make_unique<SimulatedNetwork>(net_config_)));
+    BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
+      return net_config_;
     }
 
-    std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-        TaskQueueBase* task_queue) override {
-      return std::make_unique<test::PacketTransport>(
-          task_queue, nullptr, this, test::PacketTransport::kReceiver,
-          payload_type_map_,
-          std::make_unique<FakeNetworkPipe>(
-              Clock::GetRealTimeClock(),
-              std::make_unique<SimulatedNetwork>(net_config_)));
+    BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const override {
+      return net_config_;
     }
 
     void OnFrame(const VideoFrame& video_frame) override {
@@ -946,35 +936,26 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
           task_queue_(task_queue) {}
 
    protected:
-    BuiltInNetworkBehaviorConfig GetFakeNetworkPipeConfig() {
+    BuiltInNetworkBehaviorConfig GetFakeNetworkPipeConfig() const {
       BuiltInNetworkBehaviorConfig pipe_config;
       pipe_config.link_capacity_kbps = test_bitrate_from_;
       return pipe_config;
     }
 
-    std::unique_ptr<test::PacketTransport> CreateSendTransport(
-        TaskQueueBase* task_queue,
-        Call* sender_call) override {
-      auto network =
-          std::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
-      send_simulated_network_ = network.get();
-      return std::make_unique<test::PacketTransport>(
-          task_queue, sender_call, this, test::PacketTransport::kSender,
-          test::CallTest::payload_type_map_,
-          std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
-                                            std::move(network)));
+    BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
+      return GetFakeNetworkPipeConfig();
+    }
+    BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const override {
+      return GetFakeNetworkPipeConfig();
     }
 
-    std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-        TaskQueueBase* task_queue) override {
-      auto network =
-          std::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
-      receive_simulated_network_ = network.get();
-      return std::make_unique<test::PacketTransport>(
-          task_queue, nullptr, this, test::PacketTransport::kReceiver,
-          test::CallTest::payload_type_map_,
-          std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
-                                            std::move(network)));
+    void OnTransportCreated(
+        test::PacketTransport* to_receiver,
+        SimulatedNetworkInterface* sender_network,
+        test::PacketTransport* to_sender,
+        SimulatedNetworkInterface* receiver_network) override {
+      send_simulated_network_ = sender_network;
+      receive_simulated_network_ = receiver_network;
     }
 
     void PerformTest() override {
@@ -1048,8 +1029,8 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
     const int min_bwe_;
     const int start_bwe_;
     const int max_bwe_;
-    SimulatedNetwork* send_simulated_network_;
-    SimulatedNetwork* receive_simulated_network_;
+    SimulatedNetworkInterface* send_simulated_network_;
+    SimulatedNetworkInterface* receive_simulated_network_;
     Call* sender_call_;
     TaskQueueBase* const task_queue_;
   } test(test_bitrate_from, test_bitrate_to, test_bitrate_step, min_bwe,
diff --git a/call/rampup_tests.cc b/call/rampup_tests.cc
index 4c4d56fc3c..c2848b47a2 100644
--- a/call/rampup_tests.cc
+++ b/call/rampup_tests.cc
@@ -113,18 +113,8 @@ void RampUpTester::OnVideoStreamsCreated(
   send_stream_ = send_stream;
 }
 
-std::unique_ptr<test::PacketTransport> RampUpTester::CreateSendTransport(
-    TaskQueueBase* task_queue,
-    Call* sender_call) {
-  auto network = std::make_unique<SimulatedNetwork>(forward_transport_config_);
-  send_simulated_network_ = network.get();
-  auto send_transport = std::make_unique<test::PacketTransport>(
-      task_queue, sender_call, this, test::PacketTransport::kSender,
-      test::CallTest::payload_type_map_,
-      std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
-                                        std::move(network)));
-  send_transport_ = send_transport.get();
-  return send_transport;
+BuiltInNetworkBehaviorConfig RampUpTester::GetSendTransportConfig() const {
+  return forward_transport_config_;
 }
 
 size_t RampUpTester::GetNumVideoStreams() const {
@@ -310,6 +300,17 @@ void RampUpTester::OnCallsCreated(Call* sender_call, Call* receiver_call) {
   });
 }
 
+void RampUpTester::OnTransportCreated(
+    test::PacketTransport* to_receiver,
+    SimulatedNetworkInterface* sender_network,
+    test::PacketTransport* to_sender,
+    SimulatedNetworkInterface* receiver_network) {
+  RTC_DCHECK_RUN_ON(task_queue_);
+
+  send_transport_ = to_receiver;
+  send_simulated_network_ = sender_network;
+}
+
 void RampUpTester::PollStats() {
   RTC_DCHECK_RUN_ON(task_queue_);
 
diff --git a/call/rampup_tests.h b/call/rampup_tests.h
index de0022c994..952ae6f7f8 100644
--- a/call/rampup_tests.h
+++ b/call/rampup_tests.h
@@ -83,7 +83,7 @@ class RampUpTester : public test::EndToEndTest {
   Call* sender_call_;
   VideoSendStream* send_stream_;
   test::PacketTransport* send_transport_;
-  SimulatedNetwork* send_simulated_network_;
+  SimulatedNetworkInterface* send_simulated_network_;
 
  private:
   typedef std::map<uint32_t, uint32_t> SsrcMap;
@@ -93,9 +93,7 @@ class RampUpTester : public test::EndToEndTest {
   void OnVideoStreamsCreated(VideoSendStream* send_stream,
                              const std::vector<VideoReceiveStreamInterface*>&
                                  receive_streams) override;
-  std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      TaskQueueBase* task_queue,
-      Call* sender_call) override;
+  BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override;
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
       std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
@@ -106,6 +104,10 @@ class RampUpTester : public test::EndToEndTest {
   void ModifyFlexfecConfigs(
       std::vector<FlexfecReceiveStream::Config>* receive_configs) override;
   void OnCallsCreated(Call* sender_call, Call* receiver_call) override;
+  void OnTransportCreated(test::PacketTransport* to_receiver,
+                          SimulatedNetworkInterface* sender_network,
+                          test::PacketTransport* to_sender,
+                          SimulatedNetworkInterface* receiver_network) override;
 
   const int start_bitrate_bps_;
   const int64_t min_run_time_ms_;
diff --git a/test/BUILD.gn b/test/BUILD.gn
index 86ab7cc9b7..0c71115f0d 100644
--- a/test/BUILD.gn
+++ b/test/BUILD.gn
@@ -863,6 +863,7 @@ rtc_library("direct_transport") {
     "direct_transport.h",
   ]
   deps = [
+    "../api:rtp_parameters",
     "../api:sequence_checker",
     "../api:simulated_network_api",
     "../api:transport_api",
@@ -871,6 +872,7 @@ rtc_library("direct_transport") {
     "../call:call_interfaces",
     "../call:simulated_packet_receiver",
     "../modules/rtp_rtcp:rtp_rtcp_format",
+    "../rtc_base:checks",
     "../rtc_base:macromagic",
     "../rtc_base:timeutils",
     "../rtc_base/synchronization:mutex",
diff --git a/test/call_test.cc b/test/call_test.cc
index 60b415d87f..92f8d7de71 100644
--- a/test/call_test.cc
+++ b/test/call_test.cc
@@ -20,12 +20,14 @@
 #include "api/test/create_frame_generator.h"
 #include "api/video/builtin_video_bitrate_allocator_factory.h"
 #include "call/fake_network_pipe.h"
+#include "call/packet_receiver.h"
 #include "call/simulated_network.h"
 #include "modules/audio_mixer/audio_mixer_impl.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/event.h"
 #include "rtc_base/task_queue_for_test.h"
 #include "test/fake_encoder.h"
+#include "test/rtp_rtcp_observer.h"
 #include "test/testsupport/file_utils.h"
 #include "video/config/video_encoder_config.h"
 
@@ -126,13 +128,12 @@ void CallTest::RunBaseTest(BaseTest* test) {
       CreateReceiverCall(recv_config);
     }
     test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
-    receive_transport_ = test->CreateReceiveTransport(task_queue());
-    send_transport_ =
-        test->CreateSendTransport(task_queue(), sender_call_.get());
-
+    CreateReceiveTransport(test->GetReceiveTransportConfig(), test);
+    CreateSendTransport(test->GetSendTransportConfig(), test);
+    test->OnTransportCreated(send_transport_.get(), send_simulated_network_,
+                             receive_transport_.get(),
+                             receive_simulated_network_);
     if (test->ShouldCreateReceivers()) {
-      send_transport_->SetReceiver(receiver_call_->Receiver());
-      receive_transport_->SetReceiver(sender_call_->Receiver());
       if (num_video_streams_ > 0)
         receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
       if (num_audio_streams_ > 0)
@@ -146,7 +147,7 @@ void CallTest::RunBaseTest(BaseTest* test) {
     CreateSendConfig(num_video_streams_, num_audio_streams_,
                      num_flexfec_streams_, send_transport_.get());
     if (test->ShouldCreateReceivers()) {
-      CreateMatchingReceiveConfigs(receive_transport_.get());
+      CreateMatchingReceiveConfigs();
     }
     if (num_video_streams_ > 0) {
       test->ModifyVideoConfigs(GetVideoSendConfig(), &video_receive_configs_,
@@ -235,6 +236,8 @@ void CallTest::CreateReceiverCall(const Call::Config& config) {
 }
 
 void CallTest::DestroyCalls() {
+  send_transport_.reset();
+  receive_transport_.reset();
   sender_call_.reset();
   receiver_call_.reset();
 }
@@ -568,6 +571,35 @@ void CallTest::CreateFlexfecStreams() {
   }
 }
 
+void CallTest::CreateSendTransport(const BuiltInNetworkBehaviorConfig& config,
+                                   RtpRtcpObserver* observer) {
+  PacketReceiver* receiver =
+      receiver_call_ ? receiver_call_->Receiver() : nullptr;
+
+  auto network = std::make_unique<SimulatedNetwork>(config);
+  send_simulated_network_ = network.get();
+  send_transport_ = std::make_unique<PacketTransport>(
+      task_queue(), sender_call_.get(), observer,
+      test::PacketTransport::kSender, payload_type_map_,
+      std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
+                                        std::move(network), receiver),
+      rtp_extensions_, rtp_extensions_);
+}
+
+void CallTest::CreateReceiveTransport(
+    const BuiltInNetworkBehaviorConfig& config,
+    RtpRtcpObserver* observer) {
+  auto network = std::make_unique<SimulatedNetwork>(config);
+  receive_simulated_network_ = network.get();
+  receive_transport_ = std::make_unique<PacketTransport>(
+      task_queue(), nullptr, observer, test::PacketTransport::kReceiver,
+      payload_type_map_,
+      std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
+                                        std::move(network),
+                                        sender_call_->Receiver()),
+      rtp_extensions_, rtp_extensions_);
+}
+
 void CallTest::ConnectVideoSourcesToStreams() {
   for (size_t i = 0; i < video_sources_.size(); ++i)
     video_send_streams_[i]->SetSource(video_sources_[i].get(),
@@ -710,6 +742,10 @@ const std::map<uint8_t, MediaType> CallTest::payload_type_map_ = {
     {CallTest::kVideoSendPayloadType, MediaType::VIDEO},
     {CallTest::kFakeVideoSendPayloadType, MediaType::VIDEO},
     {CallTest::kSendRtxPayloadType, MediaType::VIDEO},
+    {CallTest::kPayloadTypeVP8, MediaType::VIDEO},
+    {CallTest::kPayloadTypeVP9, MediaType::VIDEO},
+    {CallTest::kPayloadTypeH264, MediaType::VIDEO},
+    {CallTest::kPayloadTypeGeneric, MediaType::VIDEO},
     {CallTest::kRedPayloadType, MediaType::VIDEO},
     {CallTest::kRtxRedPayloadType, MediaType::VIDEO},
     {CallTest::kUlpfecPayloadType, MediaType::VIDEO},
@@ -741,27 +777,18 @@ void BaseTest::ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config) {
 
 void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {}
 
-std::unique_ptr<PacketTransport> BaseTest::CreateSendTransport(
-    TaskQueueBase* task_queue,
-    Call* sender_call) {
-  return std::make_unique<PacketTransport>(
-      task_queue, sender_call, this, test::PacketTransport::kSender,
-      CallTest::payload_type_map_,
-      std::make_unique<FakeNetworkPipe>(
-          Clock::GetRealTimeClock(),
-          std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())));
+void BaseTest::OnTransportCreated(PacketTransport* to_receiver,
+                                  SimulatedNetworkInterface* sender_network,
+                                  PacketTransport* to_sender,
+                                  SimulatedNetworkInterface* receiver_network) {
 }
 
-std::unique_ptr<PacketTransport> BaseTest::CreateReceiveTransport(
-    TaskQueueBase* task_queue) {
-  return std::make_unique<PacketTransport>(
-      task_queue, nullptr, this, test::PacketTransport::kReceiver,
-      CallTest::payload_type_map_,
-      std::make_unique<FakeNetworkPipe>(
-          Clock::GetRealTimeClock(),
-          std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())));
+BuiltInNetworkBehaviorConfig BaseTest::GetSendTransportConfig() const {
+  return BuiltInNetworkBehaviorConfig();
+}
+BuiltInNetworkBehaviorConfig BaseTest::GetReceiveTransportConfig() const {
+  return BuiltInNetworkBehaviorConfig();
 }
-
 size_t BaseTest::GetNumVideoStreams() const {
   return 1;
 }
diff --git a/test/call_test.h b/test/call_test.h
index 1fd4cd310f..3324bc4b5e 100644
--- a/test/call_test.h
+++ b/test/call_test.h
@@ -16,9 +16,11 @@
 #include <vector>
 
 #include "absl/types/optional.h"
+#include "api/array_view.h"
 #include "api/rtc_event_log/rtc_event_log.h"
 #include "api/task_queue/task_queue_base.h"
 #include "api/task_queue/task_queue_factory.h"
+#include "api/test/simulated_network.h"
 #include "api/test/video/function_video_decoder_factory.h"
 #include "api/test/video/function_video_encoder_factory.h"
 #include "api/units/time_delta.h"
@@ -76,6 +78,10 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
 
  protected:
   void RegisterRtpExtension(const RtpExtension& extension);
+  // Returns header extensions that can be parsed by the transport.
+  rtc::ArrayView<const RtpExtension> GetRegisteredExtensions() {
+    return rtp_extensions_;
+  }
 
   // RunBaseTest overwrites the audio_state of the send and receive Call configs
   // to simplify test code.
@@ -102,11 +108,23 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
   void SetSendUlpFecConfig(VideoSendStream::Config* send_config);
   void SetReceiveUlpFecConfig(
       VideoReceiveStreamInterface::Config* receive_config);
+
+  void CreateSendConfig(size_t num_video_streams,
+                        size_t num_audio_streams,
+                        size_t num_flexfec_streams) {
+    CreateSendConfig(num_video_streams, num_audio_streams, num_flexfec_streams,
+                     send_transport_.get());
+  }
   void CreateSendConfig(size_t num_video_streams,
                         size_t num_audio_streams,
                         size_t num_flexfec_streams,
                         Transport* send_transport);
 
+  void CreateMatchingVideoReceiveConfigs(
+      const VideoSendStream::Config& video_send_config) {
+    CreateMatchingVideoReceiveConfigs(video_send_config,
+                                      receive_transport_.get());
+  }
   void CreateMatchingVideoReceiveConfigs(
       const VideoSendStream::Config& video_send_config,
       Transport* rtcp_send_transport);
@@ -136,6 +154,9 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
   void CreateMatchingFecConfig(
       Transport* transport,
       const VideoSendStream::Config& video_send_config);
+  void CreateMatchingReceiveConfigs() {
+    CreateMatchingReceiveConfigs(receive_transport_.get());
+  }
   void CreateMatchingReceiveConfigs(Transport* rtcp_send_transport);
 
   void CreateFrameGeneratorCapturerWithDrift(Clock* drift_clock,
@@ -154,6 +175,16 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
   void CreateAudioStreams();
   void CreateFlexfecStreams();
 
+  // Receiver call must be created before calling CreateSendTransport in order
+  // to set a receiver.
+  // Rtp header extensions must be registered (RegisterRtpExtension(..)) before
+  // the transport is created in order for the receiving call object receive RTP
+  // packets with extensions.
+  void CreateSendTransport(const BuiltInNetworkBehaviorConfig& config,
+                           RtpRtcpObserver* observer);
+  void CreateReceiveTransport(const BuiltInNetworkBehaviorConfig& config,
+                              RtpRtcpObserver* observer);
+
   void ConnectVideoSourcesToStreams();
 
   void Start();
@@ -187,6 +218,7 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
   std::unique_ptr<webrtc::RtcEventLog> recv_event_log_;
   std::unique_ptr<Call> sender_call_;
   std::unique_ptr<PacketTransport> send_transport_;
+  SimulatedNetworkInterface* send_simulated_network_ = nullptr;
   std::vector<VideoSendStream::Config> video_send_configs_;
   std::vector<VideoEncoderConfig> video_encoder_configs_;
   std::vector<VideoSendStream*> video_send_streams_;
@@ -195,6 +227,7 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
 
   std::unique_ptr<Call> receiver_call_;
   std::unique_ptr<PacketTransport> receive_transport_;
+  SimulatedNetworkInterface* receive_simulated_network_ = nullptr;
   std::vector<VideoReceiveStreamInterface::Config> video_receive_configs_;
   std::vector<VideoReceiveStreamInterface*> video_receive_streams_;
   std::vector<AudioReceiveStreamInterface::Config> audio_receive_configs_;
@@ -265,12 +298,13 @@ class BaseTest : public RtpRtcpObserver {
   virtual void ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config);
 
   virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
+  virtual void OnTransportCreated(PacketTransport* to_receiver,
+                                  SimulatedNetworkInterface* sender_network,
+                                  PacketTransport* to_sender,
+                                  SimulatedNetworkInterface* receiver_network);
 
-  virtual std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      TaskQueueBase* task_queue,
-      Call* sender_call);
-  virtual std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-      TaskQueueBase* task_queue);
+  virtual BuiltInNetworkBehaviorConfig GetSendTransportConfig() const;
+  virtual BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const;
 
   virtual void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
diff --git a/test/direct_transport.cc b/test/direct_transport.cc
index 7e9c5aefeb..3ae0216186 100644
--- a/test/direct_transport.cc
+++ b/test/direct_transport.cc
@@ -9,12 +9,14 @@
  */
 #include "test/direct_transport.h"
 
-#include "absl/memory/memory.h"
+#include "api/media_types.h"
 #include "api/task_queue/task_queue_base.h"
 #include "api/units/time_delta.h"
 #include "call/call.h"
 #include "call/fake_network_pipe.h"
+#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtp_util.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/task_utils/repeating_task.h"
 #include "rtc_base/time_utils.h"
 
@@ -43,10 +45,27 @@ DirectTransport::DirectTransport(
     std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
     Call* send_call,
     const std::map<uint8_t, MediaType>& payload_type_map)
+    : DirectTransport(task_queue,
+                      std::move(pipe),
+                      send_call,
+                      payload_type_map,
+                      {},
+                      {}) {}
+
+DirectTransport::DirectTransport(
+    TaskQueueBase* task_queue,
+    std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
+    Call* send_call,
+    const std::map<uint8_t, MediaType>& payload_type_map,
+    rtc::ArrayView<const RtpExtension> audio_extensions,
+    rtc::ArrayView<const RtpExtension> video_extensions)
     : send_call_(send_call),
       task_queue_(task_queue),
       demuxer_(payload_type_map),
-      fake_network_(std::move(pipe)) {
+      fake_network_(std::move(pipe)),
+      use_legacy_send_(audio_extensions.empty() && video_extensions.empty()),
+      audio_extensions_(audio_extensions),
+      video_extensions_(video_extensions) {
   Start();
 }
 
@@ -69,23 +88,54 @@ bool DirectTransport::SendRtp(const uint8_t* data,
     sent_packet.info.packet_type = rtc::PacketType::kData;
     send_call_->OnSentPacket(sent_packet);
   }
-  SendPacket(data, length);
+
+  if (use_legacy_send_) {
+    LegacySendPacket(data, length);
+  } else {
+    const RtpHeaderExtensionMap* extensions = nullptr;
+    MediaType media_type = demuxer_.GetMediaType(data, length);
+    switch (demuxer_.GetMediaType(data, length)) {
+      case webrtc::MediaType::AUDIO:
+        extensions = &audio_extensions_;
+        break;
+      case webrtc::MediaType::VIDEO:
+        extensions = &video_extensions_;
+        break;
+      default:
+        RTC_CHECK_NOTREACHED();
+    }
+    RtpPacketReceived packet(extensions, Timestamp::Micros(rtc::TimeMicros()));
+    if (media_type == MediaType::VIDEO) {
+      packet.set_payload_type_frequency(kVideoPayloadTypeFrequency);
+    }
+    RTC_CHECK(packet.Parse(rtc::CopyOnWriteBuffer(data, length)));
+    fake_network_->DeliverRtpPacket(
+        media_type, std::move(packet),
+        [](const RtpPacketReceived& packet) { return false; });
+  }
+  MutexLock lock(&process_lock_);
+  if (!next_process_task_.Running())
+    ProcessPackets();
   return true;
 }
 
 bool DirectTransport::SendRtcp(const uint8_t* data, size_t length) {
-  SendPacket(data, length);
+  if (use_legacy_send_) {
+    LegacySendPacket(data, length);
+  } else {
+    fake_network_->DeliverRtcpPacket(rtc::CopyOnWriteBuffer(data, length));
+  }
+  MutexLock lock(&process_lock_);
+  if (!next_process_task_.Running())
+    ProcessPackets();
   return true;
 }
 
-void DirectTransport::SendPacket(const uint8_t* data, size_t length) {
+void DirectTransport::LegacySendPacket(const uint8_t* data, size_t length) {
   MediaType media_type = demuxer_.GetMediaType(data, length);
   int64_t send_time_us = rtc::TimeMicros();
   fake_network_->DeliverPacket(media_type, rtc::CopyOnWriteBuffer(data, length),
                                send_time_us);
-  MutexLock lock(&process_lock_);
-  if (!next_process_task_.Running())
-    ProcessPackets();
 }
 
 int DirectTransport::GetAverageDelayMs() {
diff --git a/test/direct_transport.h b/test/direct_transport.h
index d67f9ead69..4776084ae2 100644
--- a/test/direct_transport.h
+++ b/test/direct_transport.h
@@ -44,10 +44,20 @@ class Demuxer {
 // same task-queue - the one that's passed in via the constructor.
 class DirectTransport : public Transport {
  public:
+  // TODO(perkj, https://bugs.webrtc.org/7135): Remove header once downstream
+  // projects have been updated.
+  [[deprecated("Use ctor that provide header extensions.")]] DirectTransport(
+      TaskQueueBase* task_queue,
+      std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
+      Call* send_call,
+      const std::map<uint8_t, MediaType>& payload_type_map);
+
   DirectTransport(TaskQueueBase* task_queue,
                   std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
                   Call* send_call,
-                  const std::map<uint8_t, MediaType>& payload_type_map);
+                  const std::map<uint8_t, MediaType>& payload_type_map,
+                  rtc::ArrayView<const RtpExtension> audio_extensions,
+                  rtc::ArrayView<const RtpExtension> video_extensions);
 
   ~DirectTransport() override;
 
@@ -63,7 +73,7 @@ class DirectTransport : public Transport {
 
  private:
   void ProcessPackets() RTC_EXCLUSIVE_LOCKS_REQUIRED(&process_lock_);
-  void SendPacket(const uint8_t* data, size_t length);
+  void LegacySendPacket(const uint8_t* data, size_t length);
   void Start();
 
   Call* const send_call_;
@@ -75,6 +85,9 @@ class DirectTransport : public Transport {
 
   const Demuxer demuxer_;
   const std::unique_ptr<SimulatedPacketReceiverInterface> fake_network_;
+  const bool use_legacy_send_;
+  const RtpHeaderExtensionMap audio_extensions_;
+  const RtpHeaderExtensionMap video_extensions_;
 };
 }  // namespace test
 }  // namespace webrtc
diff --git a/test/layer_filtering_transport.cc b/test/layer_filtering_transport.cc
index 08c90f77a9..f5e5ee3002 100644
--- a/test/layer_filtering_transport.cc
+++ b/test/layer_filtering_transport.cc
@@ -39,8 +39,15 @@ LayerFilteringTransport::LayerFilteringTransport(
     int selected_sl,
     const std::map<uint8_t, MediaType>& payload_type_map,
     uint32_t ssrc_to_filter_min,
-    uint32_t ssrc_to_filter_max)
-    : DirectTransport(task_queue, std::move(pipe), send_call, payload_type_map),
+    uint32_t ssrc_to_filter_max,
+    rtc::ArrayView<const RtpExtension> audio_extensions,
+    rtc::ArrayView<const RtpExtension> video_extensions)
+    : DirectTransport(task_queue,
+                      std::move(pipe),
+                      send_call,
+                      payload_type_map,
+                      audio_extensions,
+                      video_extensions),
       vp8_video_payload_type_(vp8_video_payload_type),
       vp9_video_payload_type_(vp9_video_payload_type),
       vp8_depacketizer_(CreateVideoRtpDepacketizer(kVideoCodecVP8)),
@@ -59,7 +66,9 @@ LayerFilteringTransport::LayerFilteringTransport(
     uint8_t vp9_video_payload_type,
     int selected_tl,
     int selected_sl,
-    const std::map<uint8_t, MediaType>& payload_type_map)
+    const std::map<uint8_t, MediaType>& payload_type_map,
+    rtc::ArrayView<const RtpExtension> audio_extensions,
+    rtc::ArrayView<const RtpExtension> video_extensions)
     : LayerFilteringTransport(task_queue,
                               std::move(pipe),
                               send_call,
@@ -69,7 +78,9 @@ LayerFilteringTransport::LayerFilteringTransport(
                               selected_sl,
                               payload_type_map,
                               /*ssrc_to_filter_min=*/0,
-                              /*ssrc_to_filter_max=*/0xFFFFFFFF) {}
+                              /*ssrc_to_filter_max=*/0xFFFFFFFF,
+                              audio_extensions,
+                              video_extensions) {}
 
 bool LayerFilteringTransport::DiscardedLastPacket() const {
   return discarded_last_packet_;
diff --git a/test/layer_filtering_transport.h b/test/layer_filtering_transport.h
index 4606da5f7f..3aefd7159b 100644
--- a/test/layer_filtering_transport.h
+++ b/test/layer_filtering_transport.h
@@ -39,7 +39,9 @@ class LayerFilteringTransport : public test::DirectTransport {
       int selected_sl,
       const std::map<uint8_t, MediaType>& payload_type_map,
       uint32_t ssrc_to_filter_min,
-      uint32_t ssrc_to_filter_max);
+      uint32_t ssrc_to_filter_max,
+      rtc::ArrayView<const RtpExtension> audio_extensions,
+      rtc::ArrayView<const RtpExtension> video_extensions);
   LayerFilteringTransport(
       TaskQueueBase* task_queue,
       std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
@@ -48,7 +50,9 @@ class LayerFilteringTransport : public test::DirectTransport {
       uint8_t vp9_video_payload_type,
       int selected_tl,
       int selected_sl,
-      const std::map<uint8_t, MediaType>& payload_type_map);
+      const std::map<uint8_t, MediaType>& payload_type_map,
+      rtc::ArrayView<const RtpExtension> audio_extensions,
+      rtc::ArrayView<const RtpExtension> video_extensions);
   bool DiscardedLastPacket() const;
   bool SendRtp(const uint8_t* data,
                size_t length,
diff --git a/test/rtp_rtcp_observer.h b/test/rtp_rtcp_observer.h
index 0c6fd4bf00..06a438e712 100644
--- a/test/rtp_rtcp_observer.h
+++ b/test/rtp_rtcp_observer.h
@@ -87,11 +87,15 @@ class PacketTransport : public test::DirectTransport {
                   RtpRtcpObserver* observer,
                   TransportType transport_type,
                   const std::map<uint8_t, MediaType>& payload_type_map,
-                  std::unique_ptr<SimulatedPacketReceiverInterface> nw_pipe)
+                  std::unique_ptr<SimulatedPacketReceiverInterface> nw_pipe,
+                  rtc::ArrayView<const RtpExtension> audio_extensions,
+                  rtc::ArrayView<const RtpExtension> video_extensions)
       : test::DirectTransport(task_queue,
                               std::move(nw_pipe),
                               send_call,
-                              payload_type_map),
+                              payload_type_map,
+                              audio_extensions,
+                              video_extensions),
         observer_(observer),
         transport_type_(transport_type) {}
 
@@ -100,8 +104,8 @@ class PacketTransport : public test::DirectTransport {
                size_t length,
                const PacketOptions& options) override {
     EXPECT_TRUE(IsRtpPacket(rtc::MakeArrayView(packet, length)));
-    RtpRtcpObserver::Action action;
-    {
+    RtpRtcpObserver::Action action = RtpRtcpObserver::SEND_PACKET;
+    if (observer_) {
       if (transport_type_ == kSender) {
         action = observer_->OnSendRtp(packet, length);
       } else {
@@ -120,8 +124,8 @@ class PacketTransport : public test::DirectTransport {
 
   bool SendRtcp(const uint8_t* packet, size_t length) override {
     EXPECT_TRUE(IsRtcpPacket(rtc::MakeArrayView(packet, length)));
-    RtpRtcpObserver::Action action;
-    {
+    RtpRtcpObserver::Action action = RtpRtcpObserver::SEND_PACKET;
+    if (observer_) {
       if (transport_type_ == kSender) {
         action = observer_->OnSendRtcp(packet, length);
       } else {
diff --git a/video/end_to_end_tests/bandwidth_tests.cc b/video/end_to_end_tests/bandwidth_tests.cc
index 200b6fc4bd..d6610a8ec2 100644
--- a/video/end_to_end_tests/bandwidth_tests.cc
+++ b/video/end_to_end_tests/bandwidth_tests.cc
@@ -196,25 +196,12 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
           clock_(Clock::GetRealTimeClock()),
           sender_ssrc_(0),
           remb_bitrate_bps_(1000000),
-          receive_transport_(nullptr),
           state_(kWaitForFirstRampUp),
           retransmission_rate_limiter_(clock_, 1000),
           task_queue_(task_queue) {}
 
     void OnStreamsStopped() override { rtp_rtcp_ = nullptr; }
 
-    std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-        TaskQueueBase* task_queue) override {
-      auto receive_transport = std::make_unique<test::PacketTransport>(
-          task_queue, nullptr, this, test::PacketTransport::kReceiver,
-          payload_type_map_,
-          std::make_unique<FakeNetworkPipe>(
-              Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
-                                             BuiltInNetworkBehaviorConfig())));
-      receive_transport_ = receive_transport.get();
-      return receive_transport;
-    }
-
     void ModifySenderBitrateConfig(
         BitrateConstraints* bitrate_config) override {
       // Set a high start bitrate to reduce the test completion time.
@@ -231,15 +218,8 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
       encoder_config->max_bitrate_bps = 2000000;
 
       ASSERT_EQ(1u, receive_configs->size());
-      RtpRtcpInterface::Configuration config;
-      config.receiver_only = true;
-      config.clock = clock_;
-      config.outgoing_transport = receive_transport_;
-      config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-      config.local_media_ssrc = (*receive_configs)[0].rtp.local_ssrc;
-      rtp_rtcp_ = ModuleRtpRtcpImpl2::Create(config);
-      rtp_rtcp_->SetRemoteSSRC((*receive_configs)[0].rtp.remote_ssrc);
-      rtp_rtcp_->SetRTCPStatus(RtcpMode::kReducedSize);
+      remb_sender_local_ssrc_ = (*receive_configs)[0].rtp.local_ssrc;
+      remb_sender_remote_ssrc_ = (*receive_configs)[0].rtp.remote_ssrc;
     }
 
     void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
@@ -248,6 +228,23 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
       task_queue_->PostTask([this]() { PollStats(); });
     }
 
+    void OnTransportCreated(
+        test::PacketTransport* /*to_receiver*/,
+        SimulatedNetworkInterface* /*sender_network*/,
+        test::PacketTransport* to_sender,
+        SimulatedNetworkInterface* /*receiver_network*/) override {
+      RtpRtcpInterface::Configuration config;
+      config.receiver_only = true;
+      config.clock = clock_;
+      config.outgoing_transport = to_sender;
+      config.retransmission_rate_limiter = &retransmission_rate_limiter_;
+      config.local_media_ssrc = remb_sender_local_ssrc_;
+
+      rtp_rtcp_ = ModuleRtpRtcpImpl2::Create(config);
+      rtp_rtcp_->SetRemoteSSRC(remb_sender_remote_ssrc_);
+      rtp_rtcp_->SetRTCPStatus(RtcpMode::kReducedSize);
+    }
+
     void PollStats() {
       Call::Stats stats = sender_call_->GetStats();
       switch (state_) {
@@ -296,9 +293,10 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
     Call* sender_call_;
     Clock* const clock_;
     uint32_t sender_ssrc_;
+    uint32_t remb_sender_local_ssrc_ = 0;
+    uint32_t remb_sender_remote_ssrc_ = 0;
     int remb_bitrate_bps_;
     std::unique_ptr<ModuleRtpRtcpImpl2> rtp_rtcp_;
-    test::PacketTransport* receive_transport_;
     TestState state_;
     RateLimiter retransmission_rate_limiter_;
     TaskQueueBase* const task_queue_;
diff --git a/video/end_to_end_tests/call_operation_tests.cc b/video/end_to_end_tests/call_operation_tests.cc
index 41331e972c..f5b32388b1 100644
--- a/video/end_to_end_tests/call_operation_tests.cc
+++ b/video/end_to_end_tests/call_operation_tests.cc
@@ -94,31 +94,17 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
   } renderer;
 
   test::FrameForwarder frame_forwarder;
-  std::unique_ptr<test::DirectTransport> sender_transport;
-  std::unique_ptr<test::DirectTransport> receiver_transport;
 
   SendTask(
-      task_queue(), [this, &renderer, &frame_forwarder, &sender_transport,
-                     &receiver_transport]() {
+      task_queue(), [this, &renderer, &frame_forwarder]() {
         CreateCalls();
+        CreateSendTransport(BuiltInNetworkBehaviorConfig(),
+                            /*observer=*/nullptr);
 
-        sender_transport = std::make_unique<test::DirectTransport>(
-            task_queue(),
-            std::make_unique<FakeNetworkPipe>(
-                Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
-                                               BuiltInNetworkBehaviorConfig())),
-            sender_call_.get(), payload_type_map_);
-        receiver_transport = std::make_unique<test::DirectTransport>(
-            task_queue(),
-            std::make_unique<FakeNetworkPipe>(
-                Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
-                                               BuiltInNetworkBehaviorConfig())),
-            receiver_call_.get(), payload_type_map_);
-        sender_transport->SetReceiver(receiver_call_->Receiver());
-        receiver_transport->SetReceiver(sender_call_->Receiver());
-
-        CreateSendConfig(1, 0, 0, sender_transport.get());
-        CreateMatchingReceiveConfigs(receiver_transport.get());
+        CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
+                               /*observer=*/nullptr);
+        CreateSendConfig(1, 0, 0);
+        CreateMatchingReceiveConfigs();
 
         video_receive_configs_[0].renderer = &renderer;
 
@@ -145,11 +131,9 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
   EXPECT_TRUE(renderer.Wait())
       << "Timed out while waiting for the frame to render.";
 
-  SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
+  SendTask(task_queue(), [this]() {
     Stop();
     DestroyStreams();
-    sender_transport.reset();
-    receiver_transport.reset();
     DestroyCalls();
   });
 }
@@ -171,27 +155,15 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
   std::unique_ptr<test::DirectTransport> receiver_transport;
 
   SendTask(
-      task_queue(), [this, &renderer, &frame_generator, &frame_forwarder,
-                     &sender_transport, &receiver_transport]() {
+      task_queue(), [this, &renderer, &frame_generator, &frame_forwarder]() {
         CreateCalls();
+        CreateSendTransport(BuiltInNetworkBehaviorConfig(),
+                            /*observer=*/nullptr);
+        CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
+                               /*observer=*/nullptr);
 
-        sender_transport = std::make_unique<test::DirectTransport>(
-            task_queue(),
-            std::make_unique<FakeNetworkPipe>(
-                Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
-                                               BuiltInNetworkBehaviorConfig())),
-            sender_call_.get(), payload_type_map_);
-        receiver_transport = std::make_unique<test::DirectTransport>(
-            task_queue(),
-            std::make_unique<FakeNetworkPipe>(
-                Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
-                                               BuiltInNetworkBehaviorConfig())),
-            receiver_call_.get(), payload_type_map_);
-        sender_transport->SetReceiver(receiver_call_->Receiver());
-        receiver_transport->SetReceiver(sender_call_->Receiver());
-
-        CreateSendConfig(1, 0, 0, sender_transport.get());
-        CreateMatchingReceiveConfigs(receiver_transport.get());
+        CreateSendConfig(1, 0, 0);
+        CreateMatchingReceiveConfigs();
         video_receive_configs_[0].renderer = &renderer;
 
         CreateVideoStreams();
@@ -213,11 +185,9 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
   EXPECT_TRUE(renderer.Wait())
       << "Timed out while waiting for the frame to render.";
 
-  SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
+  SendTask(task_queue(), [this]() {
     Stop();
     DestroyStreams();
-    sender_transport.reset();
-    receiver_transport.reset();
     DestroyCalls();
   });
 }
diff --git a/video/end_to_end_tests/extended_reports_tests.cc b/video/end_to_end_tests/extended_reports_tests.cc
index ee37bf96ce..2897212e0b 100644
--- a/video/end_to_end_tests/extended_reports_tests.cc
+++ b/video/end_to_end_tests/extended_reports_tests.cc
@@ -158,17 +158,16 @@ class RtcpXrObserver : public test::EndToEndTest {
     return enable_zero_target_bitrate_ ? 2 : 1;
   }
 
-  std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      TaskQueueBase* task_queue,
-      Call* sender_call) {
-    auto network =
-        std::make_unique<SimulatedNetwork>(forward_transport_config_);
-    send_simulated_network_ = network.get();
-    return std::make_unique<test::PacketTransport>(
-        task_queue, sender_call, this, test::PacketTransport::kSender,
-        test::CallTest::payload_type_map_,
-        std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
-                                          std::move(network)));
+  BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
+    return forward_transport_config_;
+  }
+
+  void OnTransportCreated(
+      test::PacketTransport* to_receiver,
+      SimulatedNetworkInterface* sender_network,
+      test::PacketTransport* to_sender,
+      SimulatedNetworkInterface* receiver_network) override {
+    send_simulated_network_ = sender_network;
   }
 
   void ModifyVideoConfigs(
@@ -210,7 +209,7 @@ class RtcpXrObserver : public test::EndToEndTest {
   bool sent_zero_rtcp_target_bitrate_ RTC_GUARDED_BY(&mutex_);
   int sent_rtcp_dlrr_;
   BuiltInNetworkBehaviorConfig forward_transport_config_;
-  SimulatedNetwork* send_simulated_network_;
+  SimulatedNetworkInterface* send_simulated_network_ = nullptr;
 };
 
 TEST_F(ExtendedReportsEndToEndTest,
diff --git a/video/end_to_end_tests/fec_tests.cc b/video/end_to_end_tests/fec_tests.cc
index ff85dde53b..bf3ad0b22d 100644
--- a/video/end_to_end_tests/fec_tests.cc
+++ b/video/end_to_end_tests/fec_tests.cc
@@ -256,19 +256,12 @@ class FlexfecRenderObserver : public test::EndToEndTest,
     return SEND_PACKET;
   }
 
-  std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      TaskQueueBase* task_queue,
-      Call* sender_call) override {
+  BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
     const int kNetworkDelayMs = 100;
     BuiltInNetworkBehaviorConfig config;
     config.queue_delay_ms = kNetworkDelayMs;
-    return std::make_unique<test::PacketTransport>(
-        task_queue, sender_call, this, test::PacketTransport::kSender,
-        test::CallTest::payload_type_map_,
-        std::make_unique<FakeNetworkPipe>(
-            Clock::GetRealTimeClock(),
-            std::make_unique<SimulatedNetwork>(config)));
+    return config;
   }
 
   void OnFrame(const VideoFrame& video_frame) override {
@@ -439,20 +432,13 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
       return SEND_PACKET;
     }
 
-    std::unique_ptr<test::PacketTransport> CreateSendTransport(
-        TaskQueueBase* task_queue,
-        Call* sender_call) override {
+    BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
       // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
       // Configure some network delay.
       const int kNetworkDelayMs = 50;
       BuiltInNetworkBehaviorConfig config;
       config.queue_delay_ms = kNetworkDelayMs;
-      return std::make_unique<test::PacketTransport>(
-          task_queue, sender_call, this, test::PacketTransport::kSender,
-          payload_type_map_,
-          std::make_unique<FakeNetworkPipe>(
-              Clock::GetRealTimeClock(),
-              std::make_unique<SimulatedNetwork>(config)));
+      return config;
     }
 
     // TODO(holmer): Investigate why we don't send FEC packets when the bitrate
diff --git a/video/end_to_end_tests/multi_codec_receive_tests.cc b/video/end_to_end_tests/multi_codec_receive_tests.cc
index 811b96d322..d8ac606bfd 100644
--- a/video/end_to_end_tests/multi_codec_receive_tests.cc
+++ b/video/end_to_end_tests/multi_codec_receive_tests.cc
@@ -131,22 +131,8 @@ class MultiCodecReceiveTest : public test::CallTest {
   MultiCodecReceiveTest() {
     SendTask(task_queue(), [this]() {
       CreateCalls();
-
-      send_transport_.reset(new test::PacketTransport(
-          task_queue(), sender_call_.get(), &observer_,
-          test::PacketTransport::kSender, kPayloadTypeMap,
-          std::make_unique<FakeNetworkPipe>(
-              Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
-                                             BuiltInNetworkBehaviorConfig()))));
-      send_transport_->SetReceiver(receiver_call_->Receiver());
-
-      receive_transport_.reset(new test::PacketTransport(
-          task_queue(), receiver_call_.get(), &observer_,
-          test::PacketTransport::kReceiver, kPayloadTypeMap,
-          std::make_unique<FakeNetworkPipe>(
-              Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
-                                             BuiltInNetworkBehaviorConfig()))));
-      receive_transport_->SetReceiver(sender_call_->Receiver());
+      CreateSendTransport(BuiltInNetworkBehaviorConfig(), &observer_);
+      CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer_);
     });
   }
 
@@ -170,10 +156,6 @@ class MultiCodecReceiveTest : public test::CallTest {
   void RunTestWithCodecs(const std::vector<CodecConfig>& configs);
 
  private:
-  const std::map<uint8_t, MediaType> kPayloadTypeMap = {
-      {CallTest::kPayloadTypeVP8, MediaType::VIDEO},
-      {CallTest::kPayloadTypeVP9, MediaType::VIDEO},
-      {CallTest::kPayloadTypeH264, MediaType::VIDEO}};
   FrameObserver observer_;
 };
 
@@ -245,9 +227,9 @@ void MultiCodecReceiveTest::RunTestWithCodecs(
   // Create and start call.
   SendTask(task_queue(),
            [this, &configs, &encoder_factory, &decoder_factory]() {
-             CreateSendConfig(1, 0, 0, send_transport_.get());
+             CreateSendConfig(1, 0, 0);
              ConfigureEncoder(configs[0], &encoder_factory);
-             CreateMatchingReceiveConfigs(receive_transport_.get());
+             CreateMatchingReceiveConfigs();
              video_receive_configs_[0].renderer = &observer_;
              // Disable to avoid post-decode frame dropping in
              // VideoRenderFrames.
diff --git a/video/end_to_end_tests/multi_stream_tester.cc b/video/end_to_end_tests/multi_stream_tester.cc
index b455672de0..82e9eb9417 100644
--- a/video/end_to_end_tests/multi_stream_tester.cc
+++ b/video/end_to_end_tests/multi_stream_tester.cc
@@ -73,7 +73,6 @@ void MultiStreamTester::RunTest() {
     sender_transport = CreateSendTransport(task_queue.get(), sender_call.get());
     receiver_transport =
         CreateReceiveTransport(task_queue.get(), receiver_call.get());
-
     sender_transport->SetReceiver(receiver_call->Receiver());
     receiver_transport->SetReceiver(sender_call->Receiver());
 
@@ -158,22 +157,24 @@ void MultiStreamTester::UpdateReceiveConfig(
 std::unique_ptr<test::DirectTransport> MultiStreamTester::CreateSendTransport(
     TaskQueueBase* task_queue,
     Call* sender_call) {
+  std::vector<RtpExtension> extensions = {};
   return std::make_unique<test::DirectTransport>(
       task_queue,
       std::make_unique<FakeNetworkPipe>(
           Clock::GetRealTimeClock(),
           std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
-      sender_call, payload_type_map_);
+      sender_call, payload_type_map_, extensions, extensions);
 }
 
 std::unique_ptr<test::DirectTransport>
 MultiStreamTester::CreateReceiveTransport(TaskQueueBase* task_queue,
                                           Call* receiver_call) {
+  std::vector<RtpExtension> extensions = {};
   return std::make_unique<test::DirectTransport>(
       task_queue,
       std::make_unique<FakeNetworkPipe>(
           Clock::GetRealTimeClock(),
           std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
-      receiver_call, payload_type_map_);
+      receiver_call, payload_type_map_, extensions, extensions);
 }
 }  // namespace webrtc
diff --git a/video/end_to_end_tests/network_state_tests.cc b/video/end_to_end_tests/network_state_tests.cc
index 290848f17c..a39f9fe9e3 100644
--- a/video/end_to_end_tests/network_state_tests.cc
+++ b/video/end_to_end_tests/network_state_tests.cc
@@ -122,35 +122,25 @@ void NetworkStateEndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState(
 void NetworkStateEndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
     MediaType network_to_bring_up,
     Transport* transport) {
-  std::unique_ptr<test::DirectTransport> sender_transport;
+  SendTask(task_queue(), [this, network_to_bring_up, transport]() {
+    CreateCalls();
+    receiver_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
+    CreateSendTransport(BuiltInNetworkBehaviorConfig(),
+                        /*observer=*/nullptr);
 
-  SendTask(
-      task_queue(),
-      [this, &sender_transport, network_to_bring_up, transport]() {
-        CreateCalls();
-        receiver_call_->SignalChannelNetworkState(network_to_bring_up,
-                                                  kNetworkUp);
-        sender_transport = std::make_unique<test::DirectTransport>(
-            task_queue(),
-            std::make_unique<FakeNetworkPipe>(
-                Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
-                                               BuiltInNetworkBehaviorConfig())),
-            sender_call_.get(), payload_type_map_);
-        sender_transport->SetReceiver(receiver_call_->Receiver());
-        CreateSendConfig(1, 0, 0, sender_transport.get());
-        CreateMatchingReceiveConfigs(transport);
-        CreateVideoStreams();
-        CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
-                                     kDefaultHeight);
-        Start();
-      });
+    CreateSendConfig(1, 0, 0);
+    CreateMatchingReceiveConfigs(transport);
+    CreateVideoStreams();
+    CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
+                                 kDefaultHeight);
+    Start();
+  });
 
   SleepMs(kSilenceTimeoutMs);
 
-  SendTask(task_queue(), [this, &sender_transport]() {
+  SendTask(task_queue(), [this]() {
     Stop();
     DestroyStreams();
-    sender_transport.reset();
     DestroyCalls();
   });
 }
diff --git a/video/end_to_end_tests/retransmission_tests.cc b/video/end_to_end_tests/retransmission_tests.cc
index 99f6c917b4..45a9dae1e8 100644
--- a/video/end_to_end_tests/retransmission_tests.cc
+++ b/video/end_to_end_tests/retransmission_tests.cc
@@ -142,24 +142,13 @@ TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
     size_t GetNumVideoStreams() const override { return 0; }
     size_t GetNumAudioStreams() const override { return 1; }
 
-    std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-        TaskQueueBase* task_queue) override {
-      auto receive_transport = std::make_unique<test::PacketTransport>(
-          task_queue, nullptr, this, test::PacketTransport::kReceiver,
-          payload_type_map_,
-          std::make_unique<FakeNetworkPipe>(
-              Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
-                                             BuiltInNetworkBehaviorConfig())));
-      receive_transport_ = receive_transport.get();
-      return receive_transport;
-    }
-
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       RtpPacket rtp_packet;
       EXPECT_TRUE(rtp_packet.Parse(packet, length));
 
       if (!sequence_number_to_retransmit_) {
         sequence_number_to_retransmit_ = rtp_packet.SequenceNumber();
+        return DROP_PACKET;
 
         // Don't ask for retransmission straight away, may be deduped in pacer.
       } else if (rtp_packet.SequenceNumber() ==
@@ -186,6 +175,7 @@ TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       local_ssrc_ = (*receive_configs)[0].rtp.local_ssrc;
       remote_ssrc_ = (*receive_configs)[0].rtp.remote_ssrc;
+      receive_transport_ = (*receive_configs)[0].rtcp_send_transport;
     }
 
     void PerformTest() override {
diff --git a/video/end_to_end_tests/rtp_rtcp_tests.cc b/video/end_to_end_tests/rtp_rtcp_tests.cc
index 1ac83c3c36..32d7cd50ef 100644
--- a/video/end_to_end_tests/rtp_rtcp_tests.cc
+++ b/video/end_to_end_tests/rtp_rtcp_tests.cc
@@ -279,56 +279,35 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
     std::map<uint32_t, bool> ssrc_observed_ RTC_GUARDED_BY(mutex_);
   } observer(use_rtx);
 
-  std::unique_ptr<test::PacketTransport> send_transport;
-  std::unique_ptr<test::PacketTransport> receive_transport;
-
   VideoEncoderConfig one_stream;
 
-  SendTask(
-      task_queue(), [this, &observer, &send_transport, &receive_transport,
-                     &one_stream, use_rtx]() {
-        CreateCalls();
+  SendTask(task_queue(), [this, &observer, &one_stream, use_rtx]() {
+    CreateCalls();
+    CreateSendTransport(BuiltInNetworkBehaviorConfig(), &observer);
+    CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer);
+    CreateSendConfig(kNumSimulcastStreams, 0, 0);
 
-        send_transport = std::make_unique<test::PacketTransport>(
-            task_queue(), sender_call_.get(), &observer,
-            test::PacketTransport::kSender, payload_type_map_,
-            std::make_unique<FakeNetworkPipe>(
-                Clock::GetRealTimeClock(),
-                std::make_unique<SimulatedNetwork>(
-                    BuiltInNetworkBehaviorConfig())));
-        receive_transport = std::make_unique<test::PacketTransport>(
-            task_queue(), nullptr, &observer, test::PacketTransport::kReceiver,
-            payload_type_map_,
-            std::make_unique<FakeNetworkPipe>(
-                Clock::GetRealTimeClock(),
-                std::make_unique<SimulatedNetwork>(
-                    BuiltInNetworkBehaviorConfig())));
-        send_transport->SetReceiver(receiver_call_->Receiver());
-        receive_transport->SetReceiver(sender_call_->Receiver());
+    if (use_rtx) {
+      for (size_t i = 0; i < kNumSimulcastStreams; ++i) {
+        GetVideoSendConfig()->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
+      }
+      GetVideoSendConfig()->rtp.rtx.payload_type = kSendRtxPayloadType;
+    }
 
-        CreateSendConfig(kNumSimulcastStreams, 0, 0, send_transport.get());
+    GetVideoEncoderConfig()->video_stream_factory =
+        rtc::make_ref_counted<VideoStreamFactory>();
+    // Use the same total bitrates when sending a single stream to avoid
+    // lowering the bitrate estimate and requiring a subsequent rampup.
+    one_stream = GetVideoEncoderConfig()->Copy();
+    // one_stream.streams.resize(1);
+    one_stream.number_of_streams = 1;
+    CreateMatchingReceiveConfigs();
 
-        if (use_rtx) {
-          for (size_t i = 0; i < kNumSimulcastStreams; ++i) {
-            GetVideoSendConfig()->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
-          }
-          GetVideoSendConfig()->rtp.rtx.payload_type = kSendRtxPayloadType;
-        }
+    CreateVideoStreams();
+    CreateFrameGeneratorCapturer(30, 1280, 720);
 
-        GetVideoEncoderConfig()->video_stream_factory =
-            rtc::make_ref_counted<VideoStreamFactory>();
-        // Use the same total bitrates when sending a single stream to avoid
-        // lowering the bitrate estimate and requiring a subsequent rampup.
-        one_stream = GetVideoEncoderConfig()->Copy();
-        // one_stream.streams.resize(1);
-        one_stream.number_of_streams = 1;
-        CreateMatchingReceiveConfigs(receive_transport.get());
-
-        CreateVideoStreams();
-        CreateFrameGeneratorCapturer(30, 1280, 720);
-
-        Start();
-      });
+    Start();
+  });
 
   EXPECT_TRUE(observer.Wait())
       << "Timed out waiting for all SSRCs to send packets.";
@@ -348,7 +327,7 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
         // to wait for a second for periodic Sender Report.
         rtcp::RapidResyncRequest force_send_sr_back_request;
         rtc::Buffer packet = force_send_sr_back_request.Build();
-        static_cast<webrtc::test::DirectTransport*>(receive_transport.get())
+        static_cast<webrtc::Transport*>(receive_transport_.get())
             ->SendRtcp(packet.data(), packet.size());
       }
       CreateFrameGeneratorCapturer(30, 1280, 720);
@@ -383,11 +362,9 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
         << "Timed out waiting for all SSRCs to send packets.";
   }
 
-  SendTask(task_queue(), [this, &send_transport, &receive_transport]() {
+  SendTask(task_queue(), [this]() {
     Stop();
     DestroyStreams();
-    send_transport.reset();
-    receive_transport.reset();
     DestroyCalls();
   });
 }
@@ -478,8 +455,6 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
   static constexpr int kFrameMaxHeight = 180;
   static constexpr int kFrameRate = 15;
 
-  std::unique_ptr<test::PacketTransport> send_transport;
-  std::unique_ptr<test::PacketTransport> receive_transport;
   test::FunctionVideoEncoderFactory encoder_factory(
       []() { return VP8Encoder::Create(); });
 
@@ -490,29 +465,14 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
     lossy_delayed_link.loss_percent = 2;
     lossy_delayed_link.queue_delay_ms = 50;
 
-    send_transport = std::make_unique<test::PacketTransport>(
-        task_queue(), sender_call_.get(), &observer,
-        test::PacketTransport::kSender, payload_type_map_,
-        std::make_unique<FakeNetworkPipe>(
-            Clock::GetRealTimeClock(),
-            std::make_unique<SimulatedNetwork>(lossy_delayed_link)));
-    send_transport->SetReceiver(receiver_call_->Receiver());
-
-    BuiltInNetworkBehaviorConfig flawless_link;
-    receive_transport = std::make_unique<test::PacketTransport>(
-        task_queue(), nullptr, &observer, test::PacketTransport::kReceiver,
-        payload_type_map_,
-        std::make_unique<FakeNetworkPipe>(
-            Clock::GetRealTimeClock(),
-            std::make_unique<SimulatedNetwork>(flawless_link)));
-    receive_transport->SetReceiver(sender_call_->Receiver());
+    CreateSendTransport(lossy_delayed_link, &observer);
+    CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer);
 
     // For reduced flakyness, we use a real VP8 encoder together with NACK
     // and RTX.
     const int kNumVideoStreams = 1;
     const int kNumFlexfecStreams = 1;
-    CreateSendConfig(kNumVideoStreams, 0, kNumFlexfecStreams,
-                     send_transport.get());
+    CreateSendConfig(kNumVideoStreams, 0, kNumFlexfecStreams);
 
     GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory;
     GetVideoSendConfig()->rtp.payload_name = "VP8";
@@ -522,7 +482,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
     GetVideoSendConfig()->rtp.rtx.payload_type = kSendRtxPayloadType;
     GetVideoEncoderConfig()->codec_type = kVideoCodecVP8;
 
-    CreateMatchingReceiveConfigs(receive_transport.get());
+    CreateMatchingReceiveConfigs();
     video_receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
     video_receive_configs_[0].rtp.rtx_ssrc = kSendRtxSsrcs[0];
     video_receive_configs_[0]
@@ -533,7 +493,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
     // CreateMatchingReceiveConfigs since this is not a test::BaseTest.
     // Set up the receive config manually instead.
     FlexfecReceiveStream::Config flexfec_receive_config(
-        receive_transport.get());
+        receive_transport_.get());
     flexfec_receive_config.payload_type =
         GetVideoSendConfig()->rtp.flexfec.payload_type;
     flexfec_receive_config.rtp.remote_ssrc =
@@ -582,11 +542,9 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
   EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
 
   // Cleanup.
-  SendTask(task_queue(), [this, &send_transport, &receive_transport]() {
+  SendTask(task_queue(), [this]() {
     Stop();
     DestroyStreams();
-    send_transport.reset();
-    receive_transport.reset();
     DestroyCalls();
   });
 }
diff --git a/video/end_to_end_tests/ssrc_tests.cc b/video/end_to_end_tests/ssrc_tests.cc
index 970a568566..a3bce40fd2 100644
--- a/video/end_to_end_tests/ssrc_tests.cc
+++ b/video/end_to_end_tests/ssrc_tests.cc
@@ -12,8 +12,10 @@
 
 #include "api/test/simulated_network.h"
 #include "call/fake_network_pipe.h"
+#include "call/packet_receiver.h"
 #include "call/simulated_network.h"
 #include "modules/rtp_rtcp/source/rtp_packet.h"
+#include "modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "modules/rtp_rtcp/source/rtp_util.h"
 #include "rtc_base/task_queue_for_test.h"
 #include "test/call_test.h"
@@ -22,6 +24,12 @@
 
 namespace webrtc {
 class SsrcEndToEndTest : public test::CallTest {
+ public:
+  SsrcEndToEndTest() {
+    RegisterRtpExtension(
+        RtpExtension(RtpExtension::kTransportSequenceNumberUri, 1));
+  }
+
  protected:
   void TestSendsSetSsrcs(size_t num_ssrcs, bool send_single_ssrc_first);
 };
@@ -49,31 +57,34 @@ TEST_F(SsrcEndToEndTest, ReceiverUsesLocalSsrc) {
   RunBaseTest(&test);
 }
 
-TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
+TEST_F(SsrcEndToEndTest, UnknownRtpPacketTriggersUndemuxablePacketHandler) {
   class PacketInputObserver : public PacketReceiver {
    public:
     explicit PacketInputObserver(PacketReceiver* receiver)
         : receiver_(receiver) {}
 
-    bool Wait() { return delivered_packet_.Wait(kDefaultTimeout); }
-
-   private:
-    DeliveryStatus DeliverPacket(MediaType media_type,
-                                 rtc::CopyOnWriteBuffer packet,
-                                 int64_t packet_time_us) override {
-      if (IsRtcpPacket(packet)) {
-        return receiver_->DeliverPacket(media_type, std::move(packet),
-                                        packet_time_us);
-      }
-      DeliveryStatus delivery_status = receiver_->DeliverPacket(
-          media_type, std::move(packet), packet_time_us);
-      EXPECT_EQ(DELIVERY_UNKNOWN_SSRC, delivery_status);
-      delivered_packet_.Set();
-      return delivery_status;
+    bool Wait() {
+      return undemuxable_packet_handler_triggered_.Wait(kDefaultTimeout);
     }
 
+   private:
+    void DeliverRtpPacket(
+        MediaType media_type,
+        RtpPacketReceived packet,
+        OnUndemuxablePacketHandler undemuxable_packet_handler) override {
+      PacketReceiver::OnUndemuxablePacketHandler handler =
+          [this](const RtpPacketReceived& packet) {
+            undemuxable_packet_handler_triggered_.Set();
+            // No need to re-attempt deliver the packet.
+            return false;
+          };
+      receiver_->DeliverRtpPacket(media_type, std::move(packet),
+                                  std::move(handler));
+    }
+    void DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) override {}
+
     PacketReceiver* receiver_;
-    rtc::Event delivered_packet_;
+    rtc::Event undemuxable_packet_handler_triggered_;
   };
 
   std::unique_ptr<test::DirectTransport> send_transport;
@@ -90,7 +101,8 @@ TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
             std::make_unique<FakeNetworkPipe>(
                 Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
                                                BuiltInNetworkBehaviorConfig())),
-            sender_call_.get(), payload_type_map_);
+            sender_call_.get(), payload_type_map_, GetRegisteredExtensions(),
+            GetRegisteredExtensions());
         receive_transport = std::make_unique<test::DirectTransport>(
             task_queue(),
             std::make_unique<FakeNetworkPipe>(
diff --git a/video/end_to_end_tests/stats_tests.cc b/video/end_to_end_tests/stats_tests.cc
index 2166916cad..62acca3b5f 100644
--- a/video/end_to_end_tests/stats_tests.cc
+++ b/video/end_to_end_tests/stats_tests.cc
@@ -228,17 +228,10 @@ TEST_F(StatsEndToEndTest, GetStats) {
       return true;
     }
 
-    std::unique_ptr<test::PacketTransport> CreateSendTransport(
-        TaskQueueBase* task_queue,
-        Call* sender_call) override {
+    BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
       BuiltInNetworkBehaviorConfig network_config;
       network_config.loss_percent = 5;
-      return std::make_unique<test::PacketTransport>(
-          task_queue, sender_call, this, test::PacketTransport::kSender,
-          payload_type_map_,
-          std::make_unique<FakeNetworkPipe>(
-              Clock::GetRealTimeClock(),
-              std::make_unique<SimulatedNetwork>(network_config)));
+      return network_config;
     }
 
     void ModifySenderBitrateConfig(
@@ -349,6 +342,8 @@ TEST_F(StatsEndToEndTest, GetStats) {
 
 TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
   static const int kExtensionId = 5;
+  RegisterRtpExtension(
+      RtpExtension(RtpExtension::kVideoTimingUri, kExtensionId));
 
   class StatsObserver : public test::EndToEndTest {
    public:
@@ -514,16 +509,12 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
                      &encoder_config_with_screenshare]() {
         CreateSenderCall(send_config);
         CreateReceiverCall(recv_config);
-
-        receive_transport_ = test.CreateReceiveTransport(task_queue());
-        send_transport_ =
-            test.CreateSendTransport(task_queue(), sender_call_.get());
-        send_transport_->SetReceiver(receiver_call_->Receiver());
-        receive_transport_->SetReceiver(sender_call_->Receiver());
+        CreateReceiveTransport(test.GetReceiveTransportConfig(), &test);
+        CreateSendTransport(test.GetReceiveTransportConfig(), &test);
 
         receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
-        CreateSendConfig(1, 0, 0, send_transport_.get());
-        CreateMatchingReceiveConfigs(receive_transport_.get());
+        CreateSendConfig(1, 0, 0);
+        CreateMatchingReceiveConfigs();
 
         // Modify send and receive configs.
         GetVideoSendConfig()->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
@@ -562,8 +553,6 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
   SendTask(task_queue(), [this]() {
     Stop();
     DestroyStreams();
-    send_transport_.reset();
-    receive_transport_.reset();
     DestroyCalls();
   });
 
@@ -698,38 +687,24 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
   static const int kSendDelayMs = 30;
   static const int kReceiveDelayMs = 70;
 
-  std::unique_ptr<test::DirectTransport> sender_transport;
-  std::unique_ptr<test::DirectTransport> receiver_transport;
+  SendTask(task_queue(), [this]() {
+    BuiltInNetworkBehaviorConfig config;
+    config.queue_delay_ms = kSendDelayMs;
+    CreateCalls();
+    CreateSendTransport(config, /*observer*/ nullptr);
 
-  SendTask(task_queue(),
-           [this, &sender_transport, &receiver_transport]() {
-             BuiltInNetworkBehaviorConfig config;
-             config.queue_delay_ms = kSendDelayMs;
-             CreateCalls();
-             sender_transport = std::make_unique<test::DirectTransport>(
-                 task_queue(),
-                 std::make_unique<FakeNetworkPipe>(
-                     Clock::GetRealTimeClock(),
-                     std::make_unique<SimulatedNetwork>(config)),
-                 sender_call_.get(), payload_type_map_);
-             config.queue_delay_ms = kReceiveDelayMs;
-             receiver_transport = std::make_unique<test::DirectTransport>(
-                 task_queue(),
-                 std::make_unique<FakeNetworkPipe>(
-                     Clock::GetRealTimeClock(),
-                     std::make_unique<SimulatedNetwork>(config)),
-                 receiver_call_.get(), payload_type_map_);
-             sender_transport->SetReceiver(receiver_call_->Receiver());
-             receiver_transport->SetReceiver(sender_call_->Receiver());
+    config.queue_delay_ms = kReceiveDelayMs;
+    CreateReceiveTransport(config, /*observer*/ nullptr);
 
-             CreateSendConfig(1, 0, 0, sender_transport.get());
-             CreateMatchingReceiveConfigs(receiver_transport.get());
+    CreateSendConfig(1, 0, 0);
+    CreateMatchingReceiveConfigs();
 
-             CreateVideoStreams();
-             CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
-                                          kDefaultHeight);
-             Start();
-           });
+    CreateVideoStreams();
+    CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
+                                 kDefaultHeight);
+    receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
+    Start();
+  });
 
   int64_t start_time_ms = clock_->TimeInMilliseconds();
   while (true) {
@@ -749,11 +724,9 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
     SleepMs(10);
   }
 
-  SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
+  SendTask(task_queue(), [this]() {
     Stop();
     DestroyStreams();
-    sender_transport.reset();
-    receiver_transport.reset();
     DestroyCalls();
   });
 }
diff --git a/video/end_to_end_tests/transport_feedback_tests.cc b/video/end_to_end_tests/transport_feedback_tests.cc
index ffcf1c1020..f6e20498e3 100644
--- a/video/end_to_end_tests/transport_feedback_tests.cc
+++ b/video/end_to_end_tests/transport_feedback_tests.cc
@@ -9,7 +9,9 @@
  */
 
 #include <memory>
+#include <vector>
 
+#include "api/rtp_parameters.h"
 #include "api/task_queue/task_queue_base.h"
 #include "api/units/time_delta.h"
 #include "call/call.h"
@@ -46,14 +48,18 @@ TEST(TransportFeedbackMultiStreamTest, AssignsTransportSequenceNumbers) {
         TaskQueueBase* task_queue,
         Call* sender_call,
         const std::map<uint32_t, uint32_t>& ssrc_map,
-        const std::map<uint8_t, MediaType>& payload_type_map)
+        const std::map<uint8_t, MediaType>& payload_type_map,
+        rtc::ArrayView<const RtpExtension> audio_extensions,
+        rtc::ArrayView<const RtpExtension> video_extensions)
         : DirectTransport(task_queue,
                           std::make_unique<FakeNetworkPipe>(
                               Clock::GetRealTimeClock(),
                               std::make_unique<SimulatedNetwork>(
                                   BuiltInNetworkBehaviorConfig())),
                           sender_call,
-                          payload_type_map),
+                          payload_type_map,
+                          audio_extensions,
+                          video_extensions),
           rtx_to_media_ssrcs_(ssrc_map),
           rtx_padding_observed_(false),
           retransmit_observed_(false),
@@ -219,8 +225,12 @@ TEST(TransportFeedbackMultiStreamTest, AssignsTransportSequenceNumbers) {
       RTC_DCHECK(payload_type_map.find(kSendRtxPayloadType) ==
                  payload_type_map.end());
       payload_type_map[kSendRtxPayloadType] = MediaType::VIDEO;
+      std::vector<RtpExtension> extensions = {
+          RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+                       kTransportSequenceNumberExtensionId)};
       auto observer = std::make_unique<RtpExtensionHeaderObserver>(
-          task_queue, sender_call, rtx_to_media_ssrcs_, payload_type_map);
+          task_queue, sender_call, rtx_to_media_ssrcs_, payload_type_map,
+          extensions, extensions);
       observer_ = observer.get();
       return observer;
     }
diff --git a/video/picture_id_tests.cc b/video/picture_id_tests.cc
index 8ea9078c5d..06491b924a 100644
--- a/video/picture_id_tests.cc
+++ b/video/picture_id_tests.cc
@@ -256,15 +256,7 @@ void PictureIdTest::SetupEncoder(VideoEncoderFactory* encoder_factory,
   SendTask(
       task_queue(), [this, encoder_factory, payload_name]() {
         CreateCalls();
-
-        send_transport_.reset(new test::PacketTransport(
-            task_queue(), sender_call_.get(), observer_.get(),
-            test::PacketTransport::kSender, payload_type_map_,
-            std::make_unique<FakeNetworkPipe>(
-                Clock::GetRealTimeClock(),
-                std::make_unique<SimulatedNetwork>(
-                    BuiltInNetworkBehaviorConfig()))));
-
+        CreateSendTransport(BuiltInNetworkBehaviorConfig(), observer_.get());
         CreateSendConfig(kNumSimulcastStreams, 0, 0, send_transport_.get());
         GetVideoSendConfig()->encoder_settings.encoder_factory =
             encoder_factory;
diff --git a/video/video_analyzer.cc b/video/video_analyzer.cc
index 030c60593f..6d70762f34 100644
--- a/video/video_analyzer.cc
+++ b/video/video_analyzer.cc
@@ -218,43 +218,38 @@ rtc::VideoSourceInterface<VideoFrame>* VideoAnalyzer::OutputInterface() {
   return &captured_frame_forwarder_;
 }
 
-PacketReceiver::DeliveryStatus VideoAnalyzer::DeliverPacket(
-    MediaType media_type,
-    rtc::CopyOnWriteBuffer packet,
-    int64_t packet_time_us) {
-  // Ignore timestamps of RTCP packets. They're not synchronized with
-  // RTP packet timestamps and so they would confuse wrap_handler_.
-  if (IsRtcpPacket(packet)) {
-    return receiver_->DeliverPacket(media_type, std::move(packet),
-                                    packet_time_us);
-  }
+void VideoAnalyzer::DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) {
+  return receiver_->DeliverRtcpPacket(std::move(packet));
+}
 
+void VideoAnalyzer::DeliverRtpPacket(
+    MediaType media_type,
+    RtpPacketReceived packet,
+    PacketReceiver::OnUndemuxablePacketHandler undemuxable_packet_handler) {
   if (rtp_file_writer_) {
     test::RtpPacket p;
-    memcpy(p.data, packet.cdata(), packet.size());
+    memcpy(p.data, packet.Buffer().data(), packet.size());
     p.length = packet.size();
     p.original_length = packet.size();
     p.time_ms = clock_->TimeInMilliseconds() - start_ms_;
     rtp_file_writer_->WritePacket(&p);
   }
 
-  RtpPacket rtp_packet;
-  rtp_packet.Parse(packet);
-  if (!IsFlexfec(rtp_packet.PayloadType()) &&
-      (rtp_packet.Ssrc() == ssrc_to_analyze_ ||
-       rtp_packet.Ssrc() == rtx_ssrc_to_analyze_)) {
+  if (!IsFlexfec(packet.PayloadType()) &&
+      (packet.Ssrc() == ssrc_to_analyze_ ||
+       packet.Ssrc() == rtx_ssrc_to_analyze_)) {
     // Ignore FlexFEC timestamps, to avoid collisions with media timestamps.
     // (FlexFEC and media are sent on different SSRCs, which have different
     // timestamps spaces.)
     // Also ignore packets from wrong SSRC, but include retransmits.
     MutexLock lock(&lock_);
     int64_t timestamp =
-        wrap_handler_.Unwrap(rtp_packet.Timestamp() - rtp_timestamp_delta_);
+        wrap_handler_.Unwrap(packet.Timestamp() - rtp_timestamp_delta_);
     recv_times_[timestamp] = clock_->CurrentNtpInMilliseconds();
   }
 
-  return receiver_->DeliverPacket(media_type, std::move(packet),
-                                  packet_time_us);
+  return receiver_->DeliverRtpPacket(media_type, std::move(packet),
+                                     std::move(undemuxable_packet_handler));
 }
 
 void VideoAnalyzer::PreEncodeOnFrame(const VideoFrame& video_frame) {
diff --git a/video/video_analyzer.h b/video/video_analyzer.h
index bf4de5f8b1..448af7ebb7 100644
--- a/video/video_analyzer.h
+++ b/video/video_analyzer.h
@@ -67,9 +67,11 @@ class VideoAnalyzer : public PacketReceiver,
   rtc::VideoSinkInterface<VideoFrame>* InputInterface();
   rtc::VideoSourceInterface<VideoFrame>* OutputInterface();
 
-  DeliveryStatus DeliverPacket(MediaType media_type,
-                               rtc::CopyOnWriteBuffer packet,
-                               int64_t packet_time_us) override;
+  void DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) override;
+  void DeliverRtpPacket(MediaType media_type,
+                        RtpPacketReceived packet,
+                        PacketReceiver::OnUndemuxablePacketHandler
+                            undemuxable_packet_handler) override;
 
   void PreEncodeOnFrame(const VideoFrame& video_frame);
   void PostEncodeOnFrame(size_t stream_id, uint32_t timestamp);
diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc
index d05a2017c5..5d179178f2 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -411,26 +411,27 @@ VideoQualityTest::VideoQualityTest(
     encoder_factory_ = std::make_unique<InternalEncoderFactory>();
   }
 
-  payload_type_map_ = test::CallTest::payload_type_map_;
-  RTC_DCHECK(payload_type_map_.find(kPayloadTypeH264) ==
-             payload_type_map_.end());
-  RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP8) ==
-             payload_type_map_.end());
-  RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP9) ==
-             payload_type_map_.end());
-  RTC_DCHECK(payload_type_map_.find(kPayloadTypeGeneric) ==
-             payload_type_map_.end());
-  payload_type_map_[kPayloadTypeH264] = webrtc::MediaType::VIDEO;
-  payload_type_map_[kPayloadTypeVP8] = webrtc::MediaType::VIDEO;
-  payload_type_map_[kPayloadTypeVP9] = webrtc::MediaType::VIDEO;
-  payload_type_map_[kPayloadTypeGeneric] = webrtc::MediaType::VIDEO;
-
   fec_controller_factory_ =
       std::move(injection_components_->fec_controller_factory);
   network_state_predictor_factory_ =
       std::move(injection_components_->network_state_predictor_factory);
   network_controller_factory_ =
       std::move(injection_components_->network_controller_factory);
+
+  // Register header extensions that are used by transport to identify
+  // extensions when parsing incomig packets.
+  RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+                                    kTransportSequenceNumberExtensionId));
+  RegisterRtpExtension(
+      RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
+  RegisterRtpExtension(RtpExtension(RtpExtension::kGenericFrameDescriptorUri00,
+                                    kGenericFrameDescriptorExtensionId00));
+  RegisterRtpExtension(RtpExtension(RtpExtension::kDependencyDescriptorUri,
+                                    kRtpExtensionDependencyDescriptor));
+  RegisterRtpExtension(RtpExtension(RtpExtension::kVideoContentTypeUri,
+                                    kVideoContentTypeExtensionId));
+  RegisterRtpExtension(
+      RtpExtension(RtpExtension::kVideoTimingUri, kVideoTimingExtensionId));
 }
 
 VideoQualityTest::InjectionComponents::InjectionComponents() = default;
@@ -1185,7 +1186,8 @@ VideoQualityTest::CreateSendTransport() {
       params_.video[0].selected_tl, params_.ss[0].selected_sl,
       payload_type_map_, kVideoSendSsrcs[0],
       static_cast<uint32_t>(kVideoSendSsrcs[0] + params_.ss[0].streams.size() -
-                            1));
+                            1),
+      GetRegisteredExtensions(), GetRegisteredExtensions());
 }
 
 std::unique_ptr<test::DirectTransport>
@@ -1199,7 +1201,8 @@ VideoQualityTest::CreateReceiveTransport() {
   return std::make_unique<test::DirectTransport>(
       task_queue(),
       std::make_unique<FakeNetworkPipe>(clock_, std::move(network_behavior)),
-      receiver_call_.get(), payload_type_map_);
+      receiver_call_.get(), payload_type_map_, GetRegisteredExtensions(),
+      GetRegisteredExtensions());
 }
 
 void VideoQualityTest::RunWithAnalyzer(const Params& params) {
diff --git a/video/video_quality_test.h b/video/video_quality_test.h
index d1f630557e..f66256e94c 100644
--- a/video/video_quality_test.h
+++ b/video/video_quality_test.h
@@ -65,8 +65,6 @@ class VideoQualityTest : public test::CallTest,
   static std::vector<int> ParseCSV(const std::string& str);
 
  protected:
-  std::map<uint8_t, webrtc::MediaType> payload_type_map_;
-
   // No-op implementation to be able to instantiate this class from non-TEST_F
   // locations.
   void TestBody() override;
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index d4da883ce9..f0563569ee 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -19,6 +19,7 @@
 #include "api/test/metrics/global_metrics_logger_and_exporter.h"
 #include "api/test/metrics/metric.h"
 #include "api/test/simulated_network.h"
+#include "api/units/time_delta.h"
 #include "api/video/builtin_video_bitrate_allocator_factory.h"
 #include "api/video/encoded_image.h"
 #include "api/video/video_bitrate_allocation.h"
@@ -68,6 +69,7 @@
 #include "test/gtest.h"
 #include "test/null_transport.h"
 #include "test/rtcp_packet_parser.h"
+#include "test/rtp_rtcp_observer.h"
 #include "test/video_encoder_proxy_factory.h"
 #include "video/config/encoder_stream_factory.h"
 #include "video/send_statistics_proxy.h"
@@ -600,21 +602,14 @@ class UlpfecObserver : public test::EndToEndTest {
     return SEND_PACKET;
   }
 
-  std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      TaskQueueBase* task_queue,
-      Call* sender_call) override {
+  BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
     // Configure some network delay.
     const int kNetworkDelayMs = 100;
     BuiltInNetworkBehaviorConfig config;
     config.loss_percent = 5;
     config.queue_delay_ms = kNetworkDelayMs;
-    return std::make_unique<test::PacketTransport>(
-        task_queue, sender_call, this, test::PacketTransport::kSender,
-        VideoSendStreamTest::payload_type_map_,
-        std::make_unique<FakeNetworkPipe>(
-            Clock::GetRealTimeClock(),
-            std::make_unique<SimulatedNetwork>(config)));
+    return config;
   }
 
   void ModifyVideoConfigs(
@@ -799,36 +794,23 @@ class FlexfecObserver : public test::EndToEndTest {
     return SEND_PACKET;
   }
 
-  std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      TaskQueueBase* task_queue,
-      Call* sender_call) override {
+  BuiltInNetworkBehaviorConfig GetSendTransportConfig() const {
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
     // Therefore we need some network delay.
     const int kNetworkDelayMs = 100;
     BuiltInNetworkBehaviorConfig config;
     config.loss_percent = 5;
     config.queue_delay_ms = kNetworkDelayMs;
-    return std::make_unique<test::PacketTransport>(
-        task_queue, sender_call, this, test::PacketTransport::kSender,
-        VideoSendStreamTest::payload_type_map_,
-        std::make_unique<FakeNetworkPipe>(
-            Clock::GetRealTimeClock(),
-            std::make_unique<SimulatedNetwork>(config)));
+    return config;
   }
 
-  std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-      TaskQueueBase* task_queue) override {
+  BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const {
     // We need the RTT to be >200 ms to send FEC and the network delay for the
     // send transport is 100 ms, so add 100 ms (but no loss) on the return link.
     BuiltInNetworkBehaviorConfig config;
     config.loss_percent = 0;
     config.queue_delay_ms = 100;
-    return std::make_unique<test::PacketTransport>(
-        task_queue, nullptr, this, test::PacketTransport::kReceiver,
-        VideoSendStreamTest::payload_type_map_,
-        std::make_unique<FakeNetworkPipe>(
-            Clock::GetRealTimeClock(),
-            std::make_unique<SimulatedNetwork>(config)));
+    return config;
   }
 
   void ModifyVideoConfigs(
@@ -1017,6 +999,7 @@ void VideoSendStreamTest::TestNackRetransmission(
                     sequence_numbers_pending_retransmission_.size() <
                 kRetransmitTarget) {
           sequence_numbers_pending_retransmission_.insert(sequence_number);
+          return DROP_PACKET;
         }
       } else {
         // Packet is a retransmission, remove it from queue and check if done.
@@ -1431,20 +1414,13 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
       return SEND_PACKET;
     }
 
-    std::unique_ptr<test::PacketTransport> CreateSendTransport(
-        TaskQueueBase* task_queue,
-        Call* sender_call) override {
+    BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
       const int kNetworkDelayMs = 50;
       BuiltInNetworkBehaviorConfig config;
       config.loss_percent = 10;
       config.link_capacity_kbps = kCapacityKbps;
       config.queue_delay_ms = kNetworkDelayMs;
-      return std::make_unique<test::PacketTransport>(
-          task_queue, sender_call, this, test::PacketTransport::kSender,
-          payload_type_map_,
-          std::make_unique<FakeNetworkPipe>(
-              Clock::GetRealTimeClock(),
-              std::make_unique<SimulatedNetwork>(config)));
+      return config;
     }
 
     void ModifyVideoConfigs(