diff --git a/audio/test/audio_bwe_integration_test.cc b/audio/test/audio_bwe_integration_test.cc
index fd68cbd627..50a4b6759c 100644
--- a/audio/test/audio_bwe_integration_test.cc
+++ b/audio/test/audio_bwe_integration_test.cc
@@ -58,6 +58,27 @@ 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 132ab0a3a5..613efcc1dd 100644
--- a/audio/test/audio_bwe_integration_test.h
+++ b/audio/test/audio_bwe_integration_test.h
@@ -39,6 +39,12 @@ 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 b7dfdb89f6..de9cf7d56f 100644
--- a/audio/test/audio_end_to_end_test.cc
+++ b/audio/test/audio_end_to_end_test.cc
@@ -31,6 +31,10 @@ constexpr int kSampleRate = 48000;
 AudioEndToEndTest::AudioEndToEndTest()
     : EndToEndTest(CallTest::kDefaultTimeout) {}
 
+BuiltInNetworkBehaviorConfig AudioEndToEndTest::GetNetworkPipeConfig() const {
+  return BuiltInNetworkBehaviorConfig();
+}
+
 size_t AudioEndToEndTest::GetNumVideoStreams() const {
   return 0;
 }
@@ -59,6 +63,27 @@ 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) {
@@ -85,7 +110,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(GetSendTransportConfig().queue_delay_ms + kExtraRecordTimeMs);
+  SleepMs(GetNetworkPipeConfig().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 607fe692be..6afa0baea3 100644
--- a/audio/test/audio_end_to_end_test.h
+++ b/audio/test/audio_end_to_end_test.h
@@ -32,6 +32,8 @@ 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;
@@ -43,6 +45,12 @@ 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 1c81432574..c637bff94e 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 GetSendTransportConfig() const override {
+  BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() 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 f385eb9dcc..948dcbc8f2 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 GetSendTransportConfig() const override {
+  BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() 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 c4bfe8306f..f383627dbe 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 GetSendTransportConfig() const override {
+    BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() 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 0c7dc6cbee..07de99ac37 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 GetSendTransportConfig() const override {
+    BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() 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 afa3136e0a..5fb05e59d9 100644
--- a/call/bitrate_estimator_tests.cc
+++ b/call/bitrate_estimator_tests.cc
@@ -7,7 +7,6 @@
  *  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>
@@ -16,6 +15,7 @@
 #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,6 +24,7 @@
 #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"
@@ -112,9 +113,20 @@ class BitrateEstimatorTest : public test::CallTest {
     SendTask(task_queue(), [this]() {
       CreateCalls();
 
-      CreateSendTransport(BuiltInNetworkBehaviorConfig(), /*observer=*/nullptr);
-      CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
-                             /*observer=*/nullptr);
+      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());
 
       VideoSendStream::Config video_send_config(send_transport_.get());
       video_send_config.rtp.ssrcs.push_back(kVideoSendSsrcs[0]);
@@ -148,6 +160,10 @@ class BitrateEstimatorTest : public test::CallTest {
         delete stream;
       }
       streams_.clear();
+
+      send_transport_.reset();
+      receive_transport_.reset();
+
       DestroyCalls();
     });
   }
@@ -229,6 +245,8 @@ 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 a50f5ee605..218ab7c9a8 100644
--- a/call/call_perf_tests.cc
+++ b/call/call_perf_tests.cc
@@ -243,26 +243,23 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
         test::PacketTransport::kSender, audio_pt_map,
         std::make_unique<FakeNetworkPipe>(
             Clock::GetRealTimeClock(),
-            std::make_unique<SimulatedNetwork>(audio_net_config)),
-        GetRegisteredExtensions(), GetRegisteredExtensions());
+            std::make_unique<SimulatedNetwork>(audio_net_config)));
     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())),
-        GetRegisteredExtensions(), GetRegisteredExtensions());
+        std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
+                                          std::make_unique<SimulatedNetwork>(
+                                              BuiltInNetworkBehaviorConfig())));
     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())),
-        GetRegisteredExtensions(), GetRegisteredExtensions());
+        std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
+                                          std::make_unique<SimulatedNetwork>(
+                                              BuiltInNetworkBehaviorConfig())));
     receive_transport->SetReceiver(sender_call_->Receiver());
 
     CreateSendConfig(1, 0, 0, video_send_transport.get());
@@ -415,12 +412,25 @@ void CallPerfTest::TestCaptureNtpTime(
           rtp_start_timestamp_(0) {}
 
    private:
-    BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
-      return net_config_;
+    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 GetReceiveTransportConfig() 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_)));
     }
 
     void OnFrame(const VideoFrame& video_frame) override {
@@ -936,26 +946,35 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
           task_queue_(task_queue) {}
 
    protected:
-    BuiltInNetworkBehaviorConfig GetFakeNetworkPipeConfig() const {
+    BuiltInNetworkBehaviorConfig GetFakeNetworkPipeConfig() {
       BuiltInNetworkBehaviorConfig pipe_config;
       pipe_config.link_capacity_kbps = test_bitrate_from_;
       return pipe_config;
     }
 
-    BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
-      return GetFakeNetworkPipeConfig();
-    }
-    BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const override {
-      return GetFakeNetworkPipeConfig();
+    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)));
     }
 
-    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;
+    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 PerformTest() override {
@@ -1029,8 +1048,8 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
     const int min_bwe_;
     const int start_bwe_;
     const int max_bwe_;
-    SimulatedNetworkInterface* send_simulated_network_;
-    SimulatedNetworkInterface* receive_simulated_network_;
+    SimulatedNetwork* send_simulated_network_;
+    SimulatedNetwork* 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 c2848b47a2..4c4d56fc3c 100644
--- a/call/rampup_tests.cc
+++ b/call/rampup_tests.cc
@@ -113,8 +113,18 @@ void RampUpTester::OnVideoStreamsCreated(
   send_stream_ = send_stream;
 }
 
-BuiltInNetworkBehaviorConfig RampUpTester::GetSendTransportConfig() const {
-  return forward_transport_config_;
+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;
 }
 
 size_t RampUpTester::GetNumVideoStreams() const {
@@ -300,17 +310,6 @@ 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 952ae6f7f8..de0022c994 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_;
-  SimulatedNetworkInterface* send_simulated_network_;
+  SimulatedNetwork* send_simulated_network_;
 
  private:
   typedef std::map<uint32_t, uint32_t> SsrcMap;
@@ -93,7 +93,9 @@ class RampUpTester : public test::EndToEndTest {
   void OnVideoStreamsCreated(VideoSendStream* send_stream,
                              const std::vector<VideoReceiveStreamInterface*>&
                                  receive_streams) override;
-  BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override;
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
+      TaskQueueBase* task_queue,
+      Call* sender_call) override;
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
       std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
@@ -104,10 +106,6 @@ 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 0c71115f0d..86ab7cc9b7 100644
--- a/test/BUILD.gn
+++ b/test/BUILD.gn
@@ -863,7 +863,6 @@ rtc_library("direct_transport") {
     "direct_transport.h",
   ]
   deps = [
-    "../api:rtp_parameters",
     "../api:sequence_checker",
     "../api:simulated_network_api",
     "../api:transport_api",
@@ -872,7 +871,6 @@ 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 92f8d7de71..60b415d87f 100644
--- a/test/call_test.cc
+++ b/test/call_test.cc
@@ -20,14 +20,12 @@
 #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"
 
@@ -128,12 +126,13 @@ void CallTest::RunBaseTest(BaseTest* test) {
       CreateReceiverCall(recv_config);
     }
     test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
-    CreateReceiveTransport(test->GetReceiveTransportConfig(), test);
-    CreateSendTransport(test->GetSendTransportConfig(), test);
-    test->OnTransportCreated(send_transport_.get(), send_simulated_network_,
-                             receive_transport_.get(),
-                             receive_simulated_network_);
+    receive_transport_ = test->CreateReceiveTransport(task_queue());
+    send_transport_ =
+        test->CreateSendTransport(task_queue(), sender_call_.get());
+
     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)
@@ -147,7 +146,7 @@ void CallTest::RunBaseTest(BaseTest* test) {
     CreateSendConfig(num_video_streams_, num_audio_streams_,
                      num_flexfec_streams_, send_transport_.get());
     if (test->ShouldCreateReceivers()) {
-      CreateMatchingReceiveConfigs();
+      CreateMatchingReceiveConfigs(receive_transport_.get());
     }
     if (num_video_streams_ > 0) {
       test->ModifyVideoConfigs(GetVideoSendConfig(), &video_receive_configs_,
@@ -236,8 +235,6 @@ void CallTest::CreateReceiverCall(const Call::Config& config) {
 }
 
 void CallTest::DestroyCalls() {
-  send_transport_.reset();
-  receive_transport_.reset();
   sender_call_.reset();
   receiver_call_.reset();
 }
@@ -571,35 +568,6 @@ 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(),
@@ -742,10 +710,6 @@ 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},
@@ -777,18 +741,27 @@ void BaseTest::ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config) {
 
 void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {}
 
-void BaseTest::OnTransportCreated(PacketTransport* to_receiver,
-                                  SimulatedNetworkInterface* sender_network,
-                                  PacketTransport* to_sender,
-                                  SimulatedNetworkInterface* receiver_network) {
+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())));
 }
 
-BuiltInNetworkBehaviorConfig BaseTest::GetSendTransportConfig() const {
-  return BuiltInNetworkBehaviorConfig();
-}
-BuiltInNetworkBehaviorConfig BaseTest::GetReceiveTransportConfig() const {
-  return BuiltInNetworkBehaviorConfig();
+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())));
 }
+
 size_t BaseTest::GetNumVideoStreams() const {
   return 1;
 }
diff --git a/test/call_test.h b/test/call_test.h
index 3324bc4b5e..1fd4cd310f 100644
--- a/test/call_test.h
+++ b/test/call_test.h
@@ -16,11 +16,9 @@
 #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"
@@ -78,10 +76,6 @@ 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.
@@ -108,23 +102,11 @@ 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);
@@ -154,9 +136,6 @@ 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,
@@ -175,16 +154,6 @@ 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();
@@ -218,7 +187,6 @@ 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_;
@@ -227,7 +195,6 @@ 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_;
@@ -298,13 +265,12 @@ 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 BuiltInNetworkBehaviorConfig GetSendTransportConfig() const;
-  virtual BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const;
+  virtual std::unique_ptr<test::PacketTransport> CreateSendTransport(
+      TaskQueueBase* task_queue,
+      Call* sender_call);
+  virtual std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
+      TaskQueueBase* task_queue);
 
   virtual void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
diff --git a/test/direct_transport.cc b/test/direct_transport.cc
index 3ae0216186..7e9c5aefeb 100644
--- a/test/direct_transport.cc
+++ b/test/direct_transport.cc
@@ -9,14 +9,12 @@
  */
 #include "test/direct_transport.h"
 
-#include "api/media_types.h"
+#include "absl/memory/memory.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"
 
@@ -45,27 +43,10 @@ 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)),
-      use_legacy_send_(audio_extensions.empty() && video_extensions.empty()),
-      audio_extensions_(audio_extensions),
-      video_extensions_(video_extensions) {
+      fake_network_(std::move(pipe)) {
   Start();
 }
 
@@ -88,54 +69,23 @@ bool DirectTransport::SendRtp(const uint8_t* data,
     sent_packet.info.packet_type = rtc::PacketType::kData;
     send_call_->OnSentPacket(sent_packet);
   }
-
-  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();
+  SendPacket(data, length);
   return true;
 }
 
 bool DirectTransport::SendRtcp(const uint8_t* data, size_t 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();
+  SendPacket(data, length);
   return true;
 }
 
-void DirectTransport::LegacySendPacket(const uint8_t* data, size_t length) {
+void DirectTransport::SendPacket(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 4776084ae2..d67f9ead69 100644
--- a/test/direct_transport.h
+++ b/test/direct_transport.h
@@ -44,20 +44,10 @@ 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,
-                  rtc::ArrayView<const RtpExtension> audio_extensions,
-                  rtc::ArrayView<const RtpExtension> video_extensions);
+                  const std::map<uint8_t, MediaType>& payload_type_map);
 
   ~DirectTransport() override;
 
@@ -73,7 +63,7 @@ class DirectTransport : public Transport {
 
  private:
   void ProcessPackets() RTC_EXCLUSIVE_LOCKS_REQUIRED(&process_lock_);
-  void LegacySendPacket(const uint8_t* data, size_t length);
+  void SendPacket(const uint8_t* data, size_t length);
   void Start();
 
   Call* const send_call_;
@@ -85,9 +75,6 @@ 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 f5e5ee3002..08c90f77a9 100644
--- a/test/layer_filtering_transport.cc
+++ b/test/layer_filtering_transport.cc
@@ -39,15 +39,8 @@ 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,
-    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),
+    uint32_t ssrc_to_filter_max)
+    : DirectTransport(task_queue, std::move(pipe), send_call, payload_type_map),
       vp8_video_payload_type_(vp8_video_payload_type),
       vp9_video_payload_type_(vp9_video_payload_type),
       vp8_depacketizer_(CreateVideoRtpDepacketizer(kVideoCodecVP8)),
@@ -66,9 +59,7 @@ LayerFilteringTransport::LayerFilteringTransport(
     uint8_t vp9_video_payload_type,
     int selected_tl,
     int selected_sl,
-    const std::map<uint8_t, MediaType>& payload_type_map,
-    rtc::ArrayView<const RtpExtension> audio_extensions,
-    rtc::ArrayView<const RtpExtension> video_extensions)
+    const std::map<uint8_t, MediaType>& payload_type_map)
     : LayerFilteringTransport(task_queue,
                               std::move(pipe),
                               send_call,
@@ -78,9 +69,7 @@ LayerFilteringTransport::LayerFilteringTransport(
                               selected_sl,
                               payload_type_map,
                               /*ssrc_to_filter_min=*/0,
-                              /*ssrc_to_filter_max=*/0xFFFFFFFF,
-                              audio_extensions,
-                              video_extensions) {}
+                              /*ssrc_to_filter_max=*/0xFFFFFFFF) {}
 
 bool LayerFilteringTransport::DiscardedLastPacket() const {
   return discarded_last_packet_;
diff --git a/test/layer_filtering_transport.h b/test/layer_filtering_transport.h
index 3aefd7159b..4606da5f7f 100644
--- a/test/layer_filtering_transport.h
+++ b/test/layer_filtering_transport.h
@@ -39,9 +39,7 @@ 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,
-      rtc::ArrayView<const RtpExtension> audio_extensions,
-      rtc::ArrayView<const RtpExtension> video_extensions);
+      uint32_t ssrc_to_filter_max);
   LayerFilteringTransport(
       TaskQueueBase* task_queue,
       std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
@@ -50,9 +48,7 @@ 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,
-      rtc::ArrayView<const RtpExtension> audio_extensions,
-      rtc::ArrayView<const RtpExtension> video_extensions);
+      const std::map<uint8_t, MediaType>& payload_type_map);
   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 06a438e712..0c6fd4bf00 100644
--- a/test/rtp_rtcp_observer.h
+++ b/test/rtp_rtcp_observer.h
@@ -87,15 +87,11 @@ 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,
-                  rtc::ArrayView<const RtpExtension> audio_extensions,
-                  rtc::ArrayView<const RtpExtension> video_extensions)
+                  std::unique_ptr<SimulatedPacketReceiverInterface> nw_pipe)
       : test::DirectTransport(task_queue,
                               std::move(nw_pipe),
                               send_call,
-                              payload_type_map,
-                              audio_extensions,
-                              video_extensions),
+                              payload_type_map),
         observer_(observer),
         transport_type_(transport_type) {}
 
@@ -104,8 +100,8 @@ class PacketTransport : public test::DirectTransport {
                size_t length,
                const PacketOptions& options) override {
     EXPECT_TRUE(IsRtpPacket(rtc::MakeArrayView(packet, length)));
-    RtpRtcpObserver::Action action = RtpRtcpObserver::SEND_PACKET;
-    if (observer_) {
+    RtpRtcpObserver::Action action;
+    {
       if (transport_type_ == kSender) {
         action = observer_->OnSendRtp(packet, length);
       } else {
@@ -124,8 +120,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::SEND_PACKET;
-    if (observer_) {
+    RtpRtcpObserver::Action action;
+    {
       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 d6610a8ec2..200b6fc4bd 100644
--- a/video/end_to_end_tests/bandwidth_tests.cc
+++ b/video/end_to_end_tests/bandwidth_tests.cc
@@ -196,12 +196,25 @@ 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.
@@ -218,8 +231,15 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
       encoder_config->max_bitrate_bps = 2000000;
 
       ASSERT_EQ(1u, receive_configs->size());
-      remb_sender_local_ssrc_ = (*receive_configs)[0].rtp.local_ssrc;
-      remb_sender_remote_ssrc_ = (*receive_configs)[0].rtp.remote_ssrc;
+      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);
     }
 
     void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
@@ -228,23 +248,6 @@ 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_) {
@@ -293,10 +296,9 @@ 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 f5b32388b1..41331e972c 100644
--- a/video/end_to_end_tests/call_operation_tests.cc
+++ b/video/end_to_end_tests/call_operation_tests.cc
@@ -94,17 +94,31 @@ 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]() {
+      task_queue(), [this, &renderer, &frame_forwarder, &sender_transport,
+                     &receiver_transport]() {
         CreateCalls();
-        CreateSendTransport(BuiltInNetworkBehaviorConfig(),
-                            /*observer=*/nullptr);
 
-        CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
-                               /*observer=*/nullptr);
-        CreateSendConfig(1, 0, 0);
-        CreateMatchingReceiveConfigs();
+        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());
 
         video_receive_configs_[0].renderer = &renderer;
 
@@ -131,9 +145,11 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
   EXPECT_TRUE(renderer.Wait())
       << "Timed out while waiting for the frame to render.";
 
-  SendTask(task_queue(), [this]() {
+  SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
     Stop();
     DestroyStreams();
+    sender_transport.reset();
+    receiver_transport.reset();
     DestroyCalls();
   });
 }
@@ -155,15 +171,27 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
   std::unique_ptr<test::DirectTransport> receiver_transport;
 
   SendTask(
-      task_queue(), [this, &renderer, &frame_generator, &frame_forwarder]() {
+      task_queue(), [this, &renderer, &frame_generator, &frame_forwarder,
+                     &sender_transport, &receiver_transport]() {
         CreateCalls();
-        CreateSendTransport(BuiltInNetworkBehaviorConfig(),
-                            /*observer=*/nullptr);
-        CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
-                               /*observer=*/nullptr);
 
-        CreateSendConfig(1, 0, 0);
-        CreateMatchingReceiveConfigs();
+        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());
         video_receive_configs_[0].renderer = &renderer;
 
         CreateVideoStreams();
@@ -185,9 +213,11 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
   EXPECT_TRUE(renderer.Wait())
       << "Timed out while waiting for the frame to render.";
 
-  SendTask(task_queue(), [this]() {
+  SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
     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 2897212e0b..ee37bf96ce 100644
--- a/video/end_to_end_tests/extended_reports_tests.cc
+++ b/video/end_to_end_tests/extended_reports_tests.cc
@@ -158,16 +158,17 @@ class RtcpXrObserver : public test::EndToEndTest {
     return enable_zero_target_bitrate_ ? 2 : 1;
   }
 
-  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;
+  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)));
   }
 
   void ModifyVideoConfigs(
@@ -209,7 +210,7 @@ class RtcpXrObserver : public test::EndToEndTest {
   bool sent_zero_rtcp_target_bitrate_ RTC_GUARDED_BY(&mutex_);
   int sent_rtcp_dlrr_;
   BuiltInNetworkBehaviorConfig forward_transport_config_;
-  SimulatedNetworkInterface* send_simulated_network_ = nullptr;
+  SimulatedNetwork* send_simulated_network_;
 };
 
 TEST_F(ExtendedReportsEndToEndTest,
diff --git a/video/end_to_end_tests/fec_tests.cc b/video/end_to_end_tests/fec_tests.cc
index bf3ad0b22d..ff85dde53b 100644
--- a/video/end_to_end_tests/fec_tests.cc
+++ b/video/end_to_end_tests/fec_tests.cc
@@ -256,12 +256,19 @@ class FlexfecRenderObserver : public test::EndToEndTest,
     return SEND_PACKET;
   }
 
-  BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
+      TaskQueueBase* task_queue,
+      Call* sender_call) override {
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
     const int kNetworkDelayMs = 100;
     BuiltInNetworkBehaviorConfig config;
     config.queue_delay_ms = kNetworkDelayMs;
-    return config;
+    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)));
   }
 
   void OnFrame(const VideoFrame& video_frame) override {
@@ -432,13 +439,20 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
       return SEND_PACKET;
     }
 
-    BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
+        TaskQueueBase* task_queue,
+        Call* sender_call) 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 config;
+      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)));
     }
 
     // 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 d8ac606bfd..811b96d322 100644
--- a/video/end_to_end_tests/multi_codec_receive_tests.cc
+++ b/video/end_to_end_tests/multi_codec_receive_tests.cc
@@ -131,8 +131,22 @@ class MultiCodecReceiveTest : public test::CallTest {
   MultiCodecReceiveTest() {
     SendTask(task_queue(), [this]() {
       CreateCalls();
-      CreateSendTransport(BuiltInNetworkBehaviorConfig(), &observer_);
-      CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer_);
+
+      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());
     });
   }
 
@@ -156,6 +170,10 @@ 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_;
 };
 
@@ -227,9 +245,9 @@ void MultiCodecReceiveTest::RunTestWithCodecs(
   // Create and start call.
   SendTask(task_queue(),
            [this, &configs, &encoder_factory, &decoder_factory]() {
-             CreateSendConfig(1, 0, 0);
+             CreateSendConfig(1, 0, 0, send_transport_.get());
              ConfigureEncoder(configs[0], &encoder_factory);
-             CreateMatchingReceiveConfigs();
+             CreateMatchingReceiveConfigs(receive_transport_.get());
              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 82e9eb9417..b455672de0 100644
--- a/video/end_to_end_tests/multi_stream_tester.cc
+++ b/video/end_to_end_tests/multi_stream_tester.cc
@@ -73,6 +73,7 @@ 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());
 
@@ -157,24 +158,22 @@ 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_, extensions, extensions);
+      sender_call, payload_type_map_);
 }
 
 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_, extensions, extensions);
+      receiver_call, payload_type_map_);
 }
 }  // 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 a39f9fe9e3..290848f17c 100644
--- a/video/end_to_end_tests/network_state_tests.cc
+++ b/video/end_to_end_tests/network_state_tests.cc
@@ -122,25 +122,35 @@ void NetworkStateEndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState(
 void NetworkStateEndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
     MediaType network_to_bring_up,
     Transport* transport) {
-  SendTask(task_queue(), [this, network_to_bring_up, transport]() {
-    CreateCalls();
-    receiver_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
-    CreateSendTransport(BuiltInNetworkBehaviorConfig(),
-                        /*observer=*/nullptr);
+  std::unique_ptr<test::DirectTransport> sender_transport;
 
-    CreateSendConfig(1, 0, 0);
-    CreateMatchingReceiveConfigs(transport);
-    CreateVideoStreams();
-    CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
-                                 kDefaultHeight);
-    Start();
-  });
+  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();
+      });
 
   SleepMs(kSilenceTimeoutMs);
 
-  SendTask(task_queue(), [this]() {
+  SendTask(task_queue(), [this, &sender_transport]() {
     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 45a9dae1e8..99f6c917b4 100644
--- a/video/end_to_end_tests/retransmission_tests.cc
+++ b/video/end_to_end_tests/retransmission_tests.cc
@@ -142,13 +142,24 @@ 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() ==
@@ -175,7 +186,6 @@ 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 32d7cd50ef..1ac83c3c36 100644
--- a/video/end_to_end_tests/rtp_rtcp_tests.cc
+++ b/video/end_to_end_tests/rtp_rtcp_tests.cc
@@ -279,35 +279,56 @@ 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, &one_stream, use_rtx]() {
-    CreateCalls();
-    CreateSendTransport(BuiltInNetworkBehaviorConfig(), &observer);
-    CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer);
-    CreateSendConfig(kNumSimulcastStreams, 0, 0);
+  SendTask(
+      task_queue(), [this, &observer, &send_transport, &receive_transport,
+                     &one_stream, use_rtx]() {
+        CreateCalls();
 
-    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;
-    }
+        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());
 
-    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();
+        CreateSendConfig(kNumSimulcastStreams, 0, 0, send_transport.get());
 
-    CreateVideoStreams();
-    CreateFrameGeneratorCapturer(30, 1280, 720);
+        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;
+        }
 
-    Start();
-  });
+        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();
+      });
 
   EXPECT_TRUE(observer.Wait())
       << "Timed out waiting for all SSRCs to send packets.";
@@ -327,7 +348,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::Transport*>(receive_transport_.get())
+        static_cast<webrtc::test::DirectTransport*>(receive_transport.get())
             ->SendRtcp(packet.data(), packet.size());
       }
       CreateFrameGeneratorCapturer(30, 1280, 720);
@@ -362,9 +383,11 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
         << "Timed out waiting for all SSRCs to send packets.";
   }
 
-  SendTask(task_queue(), [this]() {
+  SendTask(task_queue(), [this, &send_transport, &receive_transport]() {
     Stop();
     DestroyStreams();
+    send_transport.reset();
+    receive_transport.reset();
     DestroyCalls();
   });
 }
@@ -455,6 +478,8 @@ 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(); });
 
@@ -465,14 +490,29 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
     lossy_delayed_link.loss_percent = 2;
     lossy_delayed_link.queue_delay_ms = 50;
 
-    CreateSendTransport(lossy_delayed_link, &observer);
-    CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer);
+    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());
 
     // 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);
+    CreateSendConfig(kNumVideoStreams, 0, kNumFlexfecStreams,
+                     send_transport.get());
 
     GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory;
     GetVideoSendConfig()->rtp.payload_name = "VP8";
@@ -482,7 +522,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
     GetVideoSendConfig()->rtp.rtx.payload_type = kSendRtxPayloadType;
     GetVideoEncoderConfig()->codec_type = kVideoCodecVP8;
 
-    CreateMatchingReceiveConfigs();
+    CreateMatchingReceiveConfigs(receive_transport.get());
     video_receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
     video_receive_configs_[0].rtp.rtx_ssrc = kSendRtxSsrcs[0];
     video_receive_configs_[0]
@@ -493,7 +533,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 =
@@ -542,9 +582,11 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
   EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
 
   // Cleanup.
-  SendTask(task_queue(), [this]() {
+  SendTask(task_queue(), [this, &send_transport, &receive_transport]() {
     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 a3bce40fd2..970a568566 100644
--- a/video/end_to_end_tests/ssrc_tests.cc
+++ b/video/end_to_end_tests/ssrc_tests.cc
@@ -12,10 +12,8 @@
 
 #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"
@@ -24,12 +22,6 @@
 
 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);
 };
@@ -57,34 +49,31 @@ TEST_F(SsrcEndToEndTest, ReceiverUsesLocalSsrc) {
   RunBaseTest(&test);
 }
 
-TEST_F(SsrcEndToEndTest, UnknownRtpPacketTriggersUndemuxablePacketHandler) {
+TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
   class PacketInputObserver : public PacketReceiver {
    public:
     explicit PacketInputObserver(PacketReceiver* receiver)
         : receiver_(receiver) {}
 
-    bool Wait() {
-      return undemuxable_packet_handler_triggered_.Wait(kDefaultTimeout);
-    }
+    bool Wait() { return delivered_packet_.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));
+    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;
     }
-    void DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) override {}
 
     PacketReceiver* receiver_;
-    rtc::Event undemuxable_packet_handler_triggered_;
+    rtc::Event delivered_packet_;
   };
 
   std::unique_ptr<test::DirectTransport> send_transport;
@@ -101,8 +90,7 @@ TEST_F(SsrcEndToEndTest, UnknownRtpPacketTriggersUndemuxablePacketHandler) {
             std::make_unique<FakeNetworkPipe>(
                 Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
                                                BuiltInNetworkBehaviorConfig())),
-            sender_call_.get(), payload_type_map_, GetRegisteredExtensions(),
-            GetRegisteredExtensions());
+            sender_call_.get(), payload_type_map_);
         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 62acca3b5f..2166916cad 100644
--- a/video/end_to_end_tests/stats_tests.cc
+++ b/video/end_to_end_tests/stats_tests.cc
@@ -228,10 +228,17 @@ TEST_F(StatsEndToEndTest, GetStats) {
       return true;
     }
 
-    BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
+        TaskQueueBase* task_queue,
+        Call* sender_call) override {
       BuiltInNetworkBehaviorConfig network_config;
       network_config.loss_percent = 5;
-      return network_config;
+      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)));
     }
 
     void ModifySenderBitrateConfig(
@@ -342,8 +349,6 @@ TEST_F(StatsEndToEndTest, GetStats) {
 
 TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
   static const int kExtensionId = 5;
-  RegisterRtpExtension(
-      RtpExtension(RtpExtension::kVideoTimingUri, kExtensionId));
 
   class StatsObserver : public test::EndToEndTest {
    public:
@@ -509,12 +514,16 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
                      &encoder_config_with_screenshare]() {
         CreateSenderCall(send_config);
         CreateReceiverCall(recv_config);
-        CreateReceiveTransport(test.GetReceiveTransportConfig(), &test);
-        CreateSendTransport(test.GetReceiveTransportConfig(), &test);
+
+        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());
 
         receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
-        CreateSendConfig(1, 0, 0);
-        CreateMatchingReceiveConfigs();
+        CreateSendConfig(1, 0, 0, send_transport_.get());
+        CreateMatchingReceiveConfigs(receive_transport_.get());
 
         // Modify send and receive configs.
         GetVideoSendConfig()->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
@@ -553,6 +562,8 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
   SendTask(task_queue(), [this]() {
     Stop();
     DestroyStreams();
+    send_transport_.reset();
+    receive_transport_.reset();
     DestroyCalls();
   });
 
@@ -687,24 +698,38 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
   static const int kSendDelayMs = 30;
   static const int kReceiveDelayMs = 70;
 
-  SendTask(task_queue(), [this]() {
-    BuiltInNetworkBehaviorConfig config;
-    config.queue_delay_ms = kSendDelayMs;
-    CreateCalls();
-    CreateSendTransport(config, /*observer*/ nullptr);
+  std::unique_ptr<test::DirectTransport> sender_transport;
+  std::unique_ptr<test::DirectTransport> receiver_transport;
 
-    config.queue_delay_ms = kReceiveDelayMs;
-    CreateReceiveTransport(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());
 
-    CreateSendConfig(1, 0, 0);
-    CreateMatchingReceiveConfigs();
+             CreateSendConfig(1, 0, 0, sender_transport.get());
+             CreateMatchingReceiveConfigs(receiver_transport.get());
 
-    CreateVideoStreams();
-    CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
-                                 kDefaultHeight);
-    receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
-    Start();
-  });
+             CreateVideoStreams();
+             CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
+                                          kDefaultHeight);
+             Start();
+           });
 
   int64_t start_time_ms = clock_->TimeInMilliseconds();
   while (true) {
@@ -724,9 +749,11 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
     SleepMs(10);
   }
 
-  SendTask(task_queue(), [this]() {
+  SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
     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 f6e20498e3..ffcf1c1020 100644
--- a/video/end_to_end_tests/transport_feedback_tests.cc
+++ b/video/end_to_end_tests/transport_feedback_tests.cc
@@ -9,9 +9,7 @@
  */
 
 #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"
@@ -48,18 +46,14 @@ 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,
-        rtc::ArrayView<const RtpExtension> audio_extensions,
-        rtc::ArrayView<const RtpExtension> video_extensions)
+        const std::map<uint8_t, MediaType>& payload_type_map)
         : DirectTransport(task_queue,
                           std::make_unique<FakeNetworkPipe>(
                               Clock::GetRealTimeClock(),
                               std::make_unique<SimulatedNetwork>(
                                   BuiltInNetworkBehaviorConfig())),
                           sender_call,
-                          payload_type_map,
-                          audio_extensions,
-                          video_extensions),
+                          payload_type_map),
           rtx_to_media_ssrcs_(ssrc_map),
           rtx_padding_observed_(false),
           retransmit_observed_(false),
@@ -225,12 +219,8 @@ 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,
-          extensions, extensions);
+          task_queue, sender_call, rtx_to_media_ssrcs_, payload_type_map);
       observer_ = observer.get();
       return observer;
     }
diff --git a/video/picture_id_tests.cc b/video/picture_id_tests.cc
index 06491b924a..8ea9078c5d 100644
--- a/video/picture_id_tests.cc
+++ b/video/picture_id_tests.cc
@@ -256,7 +256,15 @@ void PictureIdTest::SetupEncoder(VideoEncoderFactory* encoder_factory,
   SendTask(
       task_queue(), [this, encoder_factory, payload_name]() {
         CreateCalls();
-        CreateSendTransport(BuiltInNetworkBehaviorConfig(), observer_.get());
+
+        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()))));
+
         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 6d70762f34..030c60593f 100644
--- a/video/video_analyzer.cc
+++ b/video/video_analyzer.cc
@@ -218,38 +218,43 @@ rtc::VideoSourceInterface<VideoFrame>* VideoAnalyzer::OutputInterface() {
   return &captured_frame_forwarder_;
 }
 
-void VideoAnalyzer::DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) {
-  return receiver_->DeliverRtcpPacket(std::move(packet));
-}
-
-void VideoAnalyzer::DeliverRtpPacket(
+PacketReceiver::DeliveryStatus VideoAnalyzer::DeliverPacket(
     MediaType media_type,
-    RtpPacketReceived packet,
-    PacketReceiver::OnUndemuxablePacketHandler undemuxable_packet_handler) {
+    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);
+  }
+
   if (rtp_file_writer_) {
     test::RtpPacket p;
-    memcpy(p.data, packet.Buffer().data(), packet.size());
+    memcpy(p.data, packet.cdata(), packet.size());
     p.length = packet.size();
     p.original_length = packet.size();
     p.time_ms = clock_->TimeInMilliseconds() - start_ms_;
     rtp_file_writer_->WritePacket(&p);
   }
 
-  if (!IsFlexfec(packet.PayloadType()) &&
-      (packet.Ssrc() == ssrc_to_analyze_ ||
-       packet.Ssrc() == rtx_ssrc_to_analyze_)) {
+  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_)) {
     // 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(packet.Timestamp() - rtp_timestamp_delta_);
+        wrap_handler_.Unwrap(rtp_packet.Timestamp() - rtp_timestamp_delta_);
     recv_times_[timestamp] = clock_->CurrentNtpInMilliseconds();
   }
 
-  return receiver_->DeliverRtpPacket(media_type, std::move(packet),
-                                     std::move(undemuxable_packet_handler));
+  return receiver_->DeliverPacket(media_type, std::move(packet),
+                                  packet_time_us);
 }
 
 void VideoAnalyzer::PreEncodeOnFrame(const VideoFrame& video_frame) {
diff --git a/video/video_analyzer.h b/video/video_analyzer.h
index 448af7ebb7..bf4de5f8b1 100644
--- a/video/video_analyzer.h
+++ b/video/video_analyzer.h
@@ -67,11 +67,9 @@ class VideoAnalyzer : public PacketReceiver,
   rtc::VideoSinkInterface<VideoFrame>* InputInterface();
   rtc::VideoSourceInterface<VideoFrame>* OutputInterface();
 
-  void DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) override;
-  void DeliverRtpPacket(MediaType media_type,
-                        RtpPacketReceived packet,
-                        PacketReceiver::OnUndemuxablePacketHandler
-                            undemuxable_packet_handler) override;
+  DeliveryStatus DeliverPacket(MediaType media_type,
+                               rtc::CopyOnWriteBuffer packet,
+                               int64_t packet_time_us) 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 5d179178f2..d05a2017c5 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -411,27 +411,26 @@ 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;
@@ -1186,8 +1185,7 @@ 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),
-      GetRegisteredExtensions(), GetRegisteredExtensions());
+                            1));
 }
 
 std::unique_ptr<test::DirectTransport>
@@ -1201,8 +1199,7 @@ 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_, GetRegisteredExtensions(),
-      GetRegisteredExtensions());
+      receiver_call_.get(), payload_type_map_);
 }
 
 void VideoQualityTest::RunWithAnalyzer(const Params& params) {
diff --git a/video/video_quality_test.h b/video/video_quality_test.h
index f66256e94c..d1f630557e 100644
--- a/video/video_quality_test.h
+++ b/video/video_quality_test.h
@@ -65,6 +65,8 @@ 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 f0563569ee..d4da883ce9 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -19,7 +19,6 @@
 #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"
@@ -69,7 +68,6 @@
 #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"
@@ -602,14 +600,21 @@ class UlpfecObserver : public test::EndToEndTest {
     return SEND_PACKET;
   }
 
-  BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
+      TaskQueueBase* task_queue,
+      Call* sender_call) 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 config;
+    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)));
   }
 
   void ModifyVideoConfigs(
@@ -794,23 +799,36 @@ class FlexfecObserver : public test::EndToEndTest {
     return SEND_PACKET;
   }
 
-  BuiltInNetworkBehaviorConfig GetSendTransportConfig() const {
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
+      TaskQueueBase* task_queue,
+      Call* sender_call) override {
     // 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 config;
+    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)));
   }
 
-  BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const {
+  std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
+      TaskQueueBase* task_queue) override {
     // 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 config;
+    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)));
   }
 
   void ModifyVideoConfigs(
@@ -999,7 +1017,6 @@ 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.
@@ -1414,13 +1431,20 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
       return SEND_PACKET;
     }
 
-    BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override {
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
+        TaskQueueBase* task_queue,
+        Call* sender_call) override {
       const int kNetworkDelayMs = 50;
       BuiltInNetworkBehaviorConfig config;
       config.loss_percent = 10;
       config.link_capacity_kbps = kCapacityKbps;
       config.queue_delay_ms = kNetworkDelayMs;
-      return config;
+      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)));
     }
 
     void ModifyVideoConfigs(