Mark DirectTransport subclasses ctors as deprecated and switch from them

Bug: webrtc:9630
Change-Id: I6e7bf898fd95ef76758458e759d9f9aa381f89e1
Reviewed-on: https://webrtc-review.googlesource.com/94843
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Reviewed-by: Patrik Höglund <phoglund@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24345}

21 files changed, 187 insertions, 45 deletions

diff --git a/audio/BUILD.gn b/audio/BUILD.gn
index be534a0c37..ae4c67e6ec 100644
--- a/audio/BUILD.gn
+++ b/audio/BUILD.gn
@@ -100,6 +100,8 @@ if (rtc_include_tests) {
     deps = [
       ":audio",
       "../api:simulated_network_api",
+      "../call:fake_network",
+      "../call:simulated_network",
       "../system_wrappers:system_wrappers",
       "../test:test_common",
       "../test:test_support",
@@ -249,6 +251,8 @@ if (rtc_include_tests) {
     ]
     deps = [
       "../api:simulated_network_api",
+      "../call:fake_network",
+      "../call:simulated_network",
       "../common_audio",
       "../rtc_base:rtc_base_approved",
       "../system_wrappers",
diff --git a/audio/test/audio_bwe_integration_test.cc b/audio/test/audio_bwe_integration_test.cc
index 6640f6d2ac..10c8784271 100644
--- a/audio/test/audio_bwe_integration_test.cc
+++ b/audio/test/audio_bwe_integration_test.cc
@@ -11,6 +11,8 @@
 #include "audio/test/audio_bwe_integration_test.h"
 
 #include "absl/memory/memory.h"
+#include "call/fake_network_pipe.h"
+#include "call/simulated_network.h"
 #include "common_audio/wav_file.h"
 #include "system_wrappers/include/sleep.h"
 #include "test/field_trial.h"
@@ -53,14 +55,20 @@ test::PacketTransport* AudioBweTest::CreateSendTransport(
     Call* sender_call) {
   return new test::PacketTransport(
       task_queue, sender_call, this, test::PacketTransport::kSender,
-      test::CallTest::payload_type_map_, GetNetworkPipeConfig());
+      test::CallTest::payload_type_map_,
+      absl::make_unique<FakeNetworkPipe>(
+          Clock::GetRealTimeClock(),
+          absl::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
 }
 
 test::PacketTransport* AudioBweTest::CreateReceiveTransport(
     SingleThreadedTaskQueueForTesting* task_queue) {
   return new test::PacketTransport(
       task_queue, nullptr, this, test::PacketTransport::kReceiver,
-      test::CallTest::payload_type_map_, GetNetworkPipeConfig());
+      test::CallTest::payload_type_map_,
+      absl::make_unique<FakeNetworkPipe>(
+          Clock::GetRealTimeClock(),
+          absl::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
 }
 
 void AudioBweTest::PerformTest() {
diff --git a/audio/test/audio_end_to_end_test.cc b/audio/test/audio_end_to_end_test.cc
index 8ba9a047f3..02abe734bb 100644
--- a/audio/test/audio_end_to_end_test.cc
+++ b/audio/test/audio_end_to_end_test.cc
@@ -11,6 +11,8 @@
 #include <algorithm>
 
 #include "audio/test/audio_end_to_end_test.h"
+#include "call/fake_network_pipe.h"
+#include "call/simulated_network.h"
 #include "system_wrappers/include/sleep.h"
 #include "test/gtest.h"
 
@@ -63,14 +65,20 @@ test::PacketTransport* AudioEndToEndTest::CreateSendTransport(
     Call* sender_call) {
   return new test::PacketTransport(
       task_queue, sender_call, this, test::PacketTransport::kSender,
-      test::CallTest::payload_type_map_, GetNetworkPipeConfig());
+      test::CallTest::payload_type_map_,
+      absl::make_unique<FakeNetworkPipe>(
+          Clock::GetRealTimeClock(),
+          absl::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
 }
 
 test::PacketTransport* AudioEndToEndTest::CreateReceiveTransport(
     SingleThreadedTaskQueueForTesting* task_queue) {
   return new test::PacketTransport(
       task_queue, nullptr, this, test::PacketTransport::kReceiver,
-      test::CallTest::payload_type_map_, GetNetworkPipeConfig());
+      test::CallTest::payload_type_map_,
+      absl::make_unique<FakeNetworkPipe>(
+          Clock::GetRealTimeClock(),
+          absl::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
 }
 
 void AudioEndToEndTest::ModifyAudioConfigs(
diff --git a/call/BUILD.gn b/call/BUILD.gn
index e71ca5b079..b512e09e7c 100644
--- a/call/BUILD.gn
+++ b/call/BUILD.gn
@@ -371,6 +371,7 @@ if (rtc_include_tests) {
     ]
     deps = [
       ":call_interfaces",
+      ":simulated_network",
       ":video_stream_api",
       "..:webrtc_common",
       "../api:simulated_network_api",
diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc
index 00cfada83a..f2100cd60b 100644
--- a/call/call_perf_tests.cc
+++ b/call/call_perf_tests.cc
@@ -19,6 +19,8 @@
 #include "api/video/video_bitrate_allocation.h"
 #include "api/video_codecs/video_encoder_config.h"
 #include "call/call.h"
+#include "call/fake_network_pipe.h"
+#include "call/simulated_network.h"
 #include "logging/rtc_event_log/rtc_event_log.h"
 #include "modules/audio_coding/include/audio_coding_module.h"
 #include "modules/audio_device/include/test_audio_device.h"
@@ -202,19 +204,26 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
 
     audio_send_transport = absl::make_unique<test::PacketTransport>(
         &task_queue_, sender_call_.get(), &observer,
-        test::PacketTransport::kSender, audio_pt_map, audio_net_config);
+        test::PacketTransport::kSender, audio_pt_map,
+        absl::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(),
+            absl::make_unique<SimulatedNetwork>(audio_net_config)));
     audio_send_transport->SetReceiver(receiver_call_->Receiver());
 
     video_send_transport = absl::make_unique<test::PacketTransport>(
         &task_queue_, sender_call_.get(), &observer,
         test::PacketTransport::kSender, video_pt_map,
-        DefaultNetworkSimulationConfig());
+        absl::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(), absl::make_unique<SimulatedNetwork>(
+                                           DefaultNetworkSimulationConfig())));
     video_send_transport->SetReceiver(receiver_call_->Receiver());
 
     receive_transport = absl::make_unique<test::PacketTransport>(
         &task_queue_, receiver_call_.get(), &observer,
         test::PacketTransport::kReceiver, payload_type_map_,
-        DefaultNetworkSimulationConfig());
+        absl::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(), absl::make_unique<SimulatedNetwork>(
+                                           DefaultNetworkSimulationConfig())));
     receive_transport->SetReceiver(sender_call_->Receiver());
 
     CreateSendConfig(1, 0, 0, video_send_transport.get());
@@ -351,16 +360,22 @@ void CallPerfTest::TestCaptureNtpTime(
     test::PacketTransport* CreateSendTransport(
         test::SingleThreadedTaskQueueForTesting* task_queue,
         Call* sender_call) override {
-      return new test::PacketTransport(task_queue, sender_call, this,
-                                       test::PacketTransport::kSender,
-                                       payload_type_map_, net_config_);
+      return new test::PacketTransport(
+          task_queue, sender_call, this, test::PacketTransport::kSender,
+          payload_type_map_,
+          absl::make_unique<FakeNetworkPipe>(
+              Clock::GetRealTimeClock(),
+              absl::make_unique<SimulatedNetwork>(net_config_)));
     }
 
     test::PacketTransport* CreateReceiveTransport(
         test::SingleThreadedTaskQueueForTesting* task_queue) override {
-      return new test::PacketTransport(task_queue, nullptr, this,
-                                       test::PacketTransport::kReceiver,
-                                       payload_type_map_, net_config_);
+      return new test::PacketTransport(
+          task_queue, nullptr, this, test::PacketTransport::kReceiver,
+          payload_type_map_,
+          absl::make_unique<FakeNetworkPipe>(
+              Clock::GetRealTimeClock(),
+              absl::make_unique<SimulatedNetwork>(net_config_)));
     }
 
     void OnFrame(const VideoFrame& video_frame) override {
@@ -841,14 +856,22 @@ void CallPerfTest::TestMinAudioVideoBitrate(
         Call* sender_call) override {
       return send_transport_ = new test::PacketTransport(
                  task_queue, sender_call, this, test::PacketTransport::kSender,
-                 test::CallTest::payload_type_map_, GetFakeNetworkPipeConfig());
+                 test::CallTest::payload_type_map_,
+                 absl::make_unique<FakeNetworkPipe>(
+                     Clock::GetRealTimeClock(),
+                     absl::make_unique<SimulatedNetwork>(
+                         GetFakeNetworkPipeConfig())));
     }
 
     test::PacketTransport* CreateReceiveTransport(
         test::SingleThreadedTaskQueueForTesting* task_queue) override {
       return receive_transport_ = new test::PacketTransport(
                  task_queue, nullptr, this, test::PacketTransport::kReceiver,
-                 test::CallTest::payload_type_map_, GetFakeNetworkPipeConfig());
+                 test::CallTest::payload_type_map_,
+                 absl::make_unique<FakeNetworkPipe>(
+                     Clock::GetRealTimeClock(),
+                     absl::make_unique<SimulatedNetwork>(
+                         GetFakeNetworkPipeConfig())));
     }
 
     void PerformTest() override {
diff --git a/call/rampup_tests.cc b/call/rampup_tests.cc
index fcf32ad479..21caf175c8 100644
--- a/call/rampup_tests.cc
+++ b/call/rampup_tests.cc
@@ -10,6 +10,8 @@
 
 #include "call/rampup_tests.h"
 
+#include "call/fake_network_pipe.h"
+#include "call/simulated_network.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/platform_thread.h"
@@ -95,7 +97,10 @@ test::PacketTransport* RampUpTester::CreateSendTransport(
     Call* sender_call) {
   send_transport_ = new test::PacketTransport(
       task_queue, sender_call, this, test::PacketTransport::kSender,
-      test::CallTest::payload_type_map_, forward_transport_config_);
+      test::CallTest::payload_type_map_,
+      absl::make_unique<FakeNetworkPipe>(
+          Clock::GetRealTimeClock(),
+          absl::make_unique<SimulatedNetwork>(forward_transport_config_)));
   return send_transport_;
 }
 
diff --git a/test/BUILD.gn b/test/BUILD.gn
index 8431cf27c1..6a3762288d 100644
--- a/test/BUILD.gn
+++ b/test/BUILD.gn
@@ -550,7 +550,9 @@ rtc_source_set("test_common") {
     "../audio",
     "../call",
     "../call:call_interfaces",
+    "../call:fake_network",
     "../call:rtp_sender",
+    "../call:simulated_network",
     "../call:simulated_packet_receiver",
     "../call:video_stream_api",
     "../common_video",
diff --git a/test/call_test.cc b/test/call_test.cc
index 18a5b9a5fa..bf6ce2ad27 100644
--- a/test/call_test.cc
+++ b/test/call_test.cc
@@ -16,7 +16,9 @@
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/video_codecs/video_encoder_config.h"
+#include "call/fake_network_pipe.h"
 #include "call/rtp_transport_controller_send.h"
+#include "call/simulated_network.h"
 #include "modules/audio_mixer/audio_mixer_impl.h"
 #include "modules/congestion_controller/bbr/bbr_factory.h"
 #include "rtc_base/checks.h"
@@ -730,14 +732,20 @@ test::PacketTransport* BaseTest::CreateSendTransport(
     Call* sender_call) {
   return new PacketTransport(
       task_queue, sender_call, this, test::PacketTransport::kSender,
-      CallTest::payload_type_map_, DefaultNetworkSimulationConfig());
+      CallTest::payload_type_map_,
+      absl::make_unique<FakeNetworkPipe>(
+          Clock::GetRealTimeClock(), absl::make_unique<SimulatedNetwork>(
+                                         DefaultNetworkSimulationConfig())));
 }
 
 test::PacketTransport* BaseTest::CreateReceiveTransport(
     SingleThreadedTaskQueueForTesting* task_queue) {
   return new PacketTransport(
       task_queue, nullptr, this, test::PacketTransport::kReceiver,
-      CallTest::payload_type_map_, DefaultNetworkSimulationConfig());
+      CallTest::payload_type_map_,
+      absl::make_unique<FakeNetworkPipe>(
+          Clock::GetRealTimeClock(), absl::make_unique<SimulatedNetwork>(
+                                         DefaultNetworkSimulationConfig())));
 }
 
 size_t BaseTest::GetNumVideoStreams() const {
diff --git a/test/layer_filtering_transport.h b/test/layer_filtering_transport.h
index 7d2fe4f2c7..b9b2aa139e 100644
--- a/test/layer_filtering_transport.h
+++ b/test/layer_filtering_transport.h
@@ -24,6 +24,10 @@ namespace test {
 
 class LayerFilteringTransport : public test::DirectTransport {
  public:
+  // Deprecated. DO NOT USE. Use the constructor that takes an
+  // explicit pipe instead.Because there can be different ways to simulated
+  // underlying network passing implementation specific config to the transport
+  // constructor makes no sense.
   LayerFilteringTransport(SingleThreadedTaskQueueForTesting* task_queue,
                           const DefaultNetworkSimulationConfig& config,
                           Call* send_call,
@@ -34,6 +38,10 @@ class LayerFilteringTransport : public test::DirectTransport {
                           const std::map<uint8_t, MediaType>& payload_type_map,
                           uint32_t ssrc_to_filter_min,
                           uint32_t ssrc_to_filter_max);
+  // Deprecated. DO NOT USE. Use the constructor that takes an
+  // explicit pipe instead.Because there can be different ways to simulated
+  // underlying network passing implementation specific config to the transport
+  // constructor makes no sense.
   LayerFilteringTransport(SingleThreadedTaskQueueForTesting* task_queue,
                           const DefaultNetworkSimulationConfig& config,
                           Call* send_call,
diff --git a/test/rtp_rtcp_observer.h b/test/rtp_rtcp_observer.h
index aa6fc490f0..6827041a58 100644
--- a/test/rtp_rtcp_observer.h
+++ b/test/rtp_rtcp_observer.h
@@ -93,6 +93,10 @@ class PacketTransport : public test::DirectTransport {
  public:
   enum TransportType { kReceiver, kSender };
 
+  // Deprecated. DO NOT USE. Use the constructor that takes an
+  // explicit pipe instead.Because there can be different ways to simulated
+  // underlying network passing implementation specific config to the transport
+  // constructor makes no sense.
   PacketTransport(SingleThreadedTaskQueueForTesting* task_queue,
                   Call* send_call,
                   RtpRtcpObserver* observer,
diff --git a/video/end_to_end_tests/bandwidth_tests.cc b/video/end_to_end_tests/bandwidth_tests.cc
index e33feca478..839fcf30ec 100644
--- a/video/end_to_end_tests/bandwidth_tests.cc
+++ b/video/end_to_end_tests/bandwidth_tests.cc
@@ -9,6 +9,8 @@
  */
 
 #include "api/test/simulated_network.h"
+#include "call/fake_network_pipe.h"
+#include "call/simulated_network.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "rtc_base/rate_limiter.h"
 #include "system_wrappers/include/sleep.h"
@@ -165,7 +167,11 @@ TEST_P(BandwidthEndToEndTest, RembWithSendSideBwe) {
         test::SingleThreadedTaskQueueForTesting* task_queue) override {
       receive_transport_ = new test::PacketTransport(
           task_queue, nullptr, this, test::PacketTransport::kReceiver,
-          payload_type_map_, DefaultNetworkSimulationConfig());
+          payload_type_map_,
+          absl::make_unique<FakeNetworkPipe>(
+              Clock::GetRealTimeClock(),
+              absl::make_unique<SimulatedNetwork>(
+                  DefaultNetworkSimulationConfig())));
       return receive_transport_;
     }
 
diff --git a/video/end_to_end_tests/fec_tests.cc b/video/end_to_end_tests/fec_tests.cc
index 043f0cbec2..7fef99bdc2 100644
--- a/video/end_to_end_tests/fec_tests.cc
+++ b/video/end_to_end_tests/fec_tests.cc
@@ -9,6 +9,8 @@
  */
 
 #include "api/test/simulated_network.h"
+#include "call/fake_network_pipe.h"
+#include "call/simulated_network.h"
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "modules/video_coding/codecs/vp8/include/vp8.h"
 #include "test/call_test.h"
@@ -242,9 +244,12 @@ class FlexfecRenderObserver : public test::EndToEndTest,
     const int kNetworkDelayMs = 100;
     DefaultNetworkSimulationConfig config;
     config.queue_delay_ms = kNetworkDelayMs;
-    return new test::PacketTransport(task_queue, sender_call, this,
-                                     test::PacketTransport::kSender,
-                                     test::CallTest::payload_type_map_, config);
+    return new test::PacketTransport(
+        task_queue, sender_call, this, test::PacketTransport::kSender,
+        test::CallTest::payload_type_map_,
+        absl::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(),
+            absl::make_unique<SimulatedNetwork>(config)));
   }
 
   void OnFrame(const VideoFrame& video_frame) override {
@@ -427,9 +432,12 @@ TEST_P(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
       const int kNetworkDelayMs = 50;
       DefaultNetworkSimulationConfig config;
       config.queue_delay_ms = kNetworkDelayMs;
-      return new test::PacketTransport(task_queue, sender_call, this,
-                                       test::PacketTransport::kSender,
-                                       payload_type_map_, config);
+      return new test::PacketTransport(
+          task_queue, sender_call, this, test::PacketTransport::kSender,
+          payload_type_map_,
+          absl::make_unique<FakeNetworkPipe>(
+              Clock::GetRealTimeClock(),
+              absl::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 3999c83eb0..7399ef81a4 100644
--- a/video/end_to_end_tests/multi_codec_receive_tests.cc
+++ b/video/end_to_end_tests/multi_codec_receive_tests.cc
@@ -9,6 +9,8 @@
  */
 
 #include "api/test/simulated_network.h"
+#include "call/fake_network_pipe.h"
+#include "call/simulated_network.h"
 #include "modules/video_coding/codecs/h264/include/h264.h"
 #include "modules/video_coding/codecs/vp8/include/vp8.h"
 #include "modules/video_coding/codecs/vp9/include/vp9.h"
@@ -150,13 +152,19 @@ class MultiCodecReceiveTest : public test::CallTest {
       send_transport_.reset(new test::PacketTransport(
           &task_queue_, sender_call_.get(), &observer_,
           test::PacketTransport::kSender, kPayloadTypeMap,
-          DefaultNetworkSimulationConfig()));
+          absl::make_unique<FakeNetworkPipe>(
+              Clock::GetRealTimeClock(),
+              absl::make_unique<SimulatedNetwork>(
+                  DefaultNetworkSimulationConfig()))));
       send_transport_->SetReceiver(receiver_call_->Receiver());
 
       receive_transport_.reset(new test::PacketTransport(
           &task_queue_, receiver_call_.get(), &observer_,
           test::PacketTransport::kReceiver, kPayloadTypeMap,
-          DefaultNetworkSimulationConfig()));
+          absl::make_unique<FakeNetworkPipe>(
+              Clock::GetRealTimeClock(),
+              absl::make_unique<SimulatedNetwork>(
+                  DefaultNetworkSimulationConfig()))));
       receive_transport_->SetReceiver(sender_call_->Receiver());
     });
   }
diff --git a/video/end_to_end_tests/probing_tests.cc b/video/end_to_end_tests/probing_tests.cc
index 0520c6f53a..36f1c58109 100644
--- a/video/end_to_end_tests/probing_tests.cc
+++ b/video/end_to_end_tests/probing_tests.cc
@@ -9,6 +9,8 @@
  */
 
 #include "api/test/simulated_network.h"
+#include "call/fake_network_pipe.h"
+#include "call/simulated_network.h"
 #include "test/call_test.h"
 #include "test/field_trial.h"
 #include "test/gtest.h"
@@ -221,7 +223,11 @@ TEST_P(ProbingEndToEndTest, ProbeOnVideoEncoderReconfiguration) {
         Call* sender_call) override {
       send_transport_ = new test::PacketTransport(
           task_queue, sender_call, this, test::PacketTransport::kSender,
-          CallTest::payload_type_map_, DefaultNetworkSimulationConfig());
+          CallTest::payload_type_map_,
+          absl::make_unique<FakeNetworkPipe>(
+              Clock::GetRealTimeClock(),
+              absl::make_unique<SimulatedNetwork>(
+                  DefaultNetworkSimulationConfig())));
       return send_transport_;
     }
 
diff --git a/video/end_to_end_tests/receive_time_tests.cc b/video/end_to_end_tests/receive_time_tests.cc
index f3572e404b..3ca66f1d3d 100644
--- a/video/end_to_end_tests/receive_time_tests.cc
+++ b/video/end_to_end_tests/receive_time_tests.cc
@@ -10,6 +10,7 @@
 
 #include "api/test/simulated_network.h"
 #include "call/fake_network_pipe.h"
+#include "call/simulated_network.h"
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/timeutils.h"
 #include "test/call_test.h"
@@ -94,7 +95,8 @@ class ReportedReceiveTimeTester : public test::EndToEndTest {
       test::SingleThreadedTaskQueueForTesting* task_queue,
       Call* sender_call) override {
     auto pipe = absl::make_unique<FakeNetworkPipe>(
-        Clock::GetRealTimeClock(), DefaultNetworkSimulationConfig());
+        Clock::GetRealTimeClock(),
+        absl::make_unique<SimulatedNetwork>(DefaultNetworkSimulationConfig()));
     send_pipe_ = pipe.get();
     return send_transport_ = new test::PacketTransport(
                task_queue, sender_call, this, test::PacketTransport::kSender,
diff --git a/video/end_to_end_tests/retransmission_tests.cc b/video/end_to_end_tests/retransmission_tests.cc
index 8f30f14b00..7f1c832fd9 100644
--- a/video/end_to_end_tests/retransmission_tests.cc
+++ b/video/end_to_end_tests/retransmission_tests.cc
@@ -9,6 +9,8 @@
  */
 
 #include "api/test/simulated_network.h"
+#include "call/fake_network_pipe.h"
+#include "call/simulated_network.h"
 #include "modules/video_coding/codecs/vp8/include/vp8.h"
 #include "system_wrappers/include/sleep.h"
 #include "test/call_test.h"
@@ -138,7 +140,11 @@ TEST_P(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
         test::SingleThreadedTaskQueueForTesting* task_queue) override {
       test::PacketTransport* receive_transport = new test::PacketTransport(
           task_queue, nullptr, this, test::PacketTransport::kReceiver,
-          payload_type_map_, DefaultNetworkSimulationConfig());
+          payload_type_map_,
+          absl::make_unique<FakeNetworkPipe>(
+              Clock::GetRealTimeClock(),
+              absl::make_unique<SimulatedNetwork>(
+                  DefaultNetworkSimulationConfig())));
       receive_transport_ = receive_transport;
       return receive_transport;
     }
diff --git a/video/end_to_end_tests/rtp_rtcp_tests.cc b/video/end_to_end_tests/rtp_rtcp_tests.cc
index c9740650f6..5a67d5808c 100644
--- a/video/end_to_end_tests/rtp_rtcp_tests.cc
+++ b/video/end_to_end_tests/rtp_rtcp_tests.cc
@@ -9,6 +9,8 @@
  */
 
 #include "api/test/simulated_network.h"
+#include "call/fake_network_pipe.h"
+#include "call/simulated_network.h"
 #include "modules/video_coding/codecs/vp8/include/vp8.h"
 #include "test/call_test.h"
 #include "test/gtest.h"
@@ -278,10 +280,15 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
     send_transport = absl::make_unique<test::PacketTransport>(
         &task_queue_, sender_call_.get(), &observer,
         test::PacketTransport::kSender, payload_type_map_,
-        DefaultNetworkSimulationConfig());
+        absl::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(), absl::make_unique<SimulatedNetwork>(
+                                           DefaultNetworkSimulationConfig())));
     receive_transport = absl::make_unique<test::PacketTransport>(
         &task_queue_, nullptr, &observer, test::PacketTransport::kReceiver,
-        payload_type_map_, DefaultNetworkSimulationConfig());
+        payload_type_map_,
+        absl::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(), absl::make_unique<SimulatedNetwork>(
+                                           DefaultNetworkSimulationConfig())));
     send_transport->SetReceiver(receiver_call_->Receiver());
     receive_transport->SetReceiver(sender_call_->Receiver());
 
@@ -472,13 +479,19 @@ TEST_F(RtpRtcpEndToEndTest, TestFlexfecRtpStatePreservation) {
 
     send_transport = absl::make_unique<test::PacketTransport>(
         &task_queue_, sender_call_.get(), &observer,
-        test::PacketTransport::kSender, payload_type_map_, lossy_delayed_link);
+        test::PacketTransport::kSender, payload_type_map_,
+        absl::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(),
+            absl::make_unique<SimulatedNetwork>(lossy_delayed_link)));
     send_transport->SetReceiver(receiver_call_->Receiver());
 
     DefaultNetworkSimulationConfig flawless_link;
     receive_transport = absl::make_unique<test::PacketTransport>(
         &task_queue_, nullptr, &observer, test::PacketTransport::kReceiver,
-        payload_type_map_, flawless_link);
+        payload_type_map_,
+        absl::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(),
+            absl::make_unique<SimulatedNetwork>(flawless_link)));
     receive_transport->SetReceiver(sender_call_->Receiver());
 
     // For reduced flakyness, we use a real VP8 encoder together with NACK
diff --git a/video/end_to_end_tests/stats_tests.cc b/video/end_to_end_tests/stats_tests.cc
index 3f40cdea3e..e05737641c 100644
--- a/video/end_to_end_tests/stats_tests.cc
+++ b/video/end_to_end_tests/stats_tests.cc
@@ -233,9 +233,12 @@ TEST_F(StatsEndToEndTest, GetStats) {
         Call* sender_call) override {
       DefaultNetworkSimulationConfig network_config;
       network_config.loss_percent = 5;
-      return new test::PacketTransport(task_queue, sender_call, this,
-                                       test::PacketTransport::kSender,
-                                       payload_type_map_, network_config);
+      return new test::PacketTransport(
+          task_queue, sender_call, this, test::PacketTransport::kSender,
+          payload_type_map_,
+          absl::make_unique<FakeNetworkPipe>(
+              Clock::GetRealTimeClock(),
+              absl::make_unique<SimulatedNetwork>(network_config)));
     }
     void ModifySenderCallConfig(Call::Config* config) override {
       config->bitrate_config.start_bitrate_bps = kStartBitrateBps;
diff --git a/video/picture_id_tests.cc b/video/picture_id_tests.cc
index 60f11ca4e6..b93a7e7db3 100644
--- a/video/picture_id_tests.cc
+++ b/video/picture_id_tests.cc
@@ -9,6 +9,8 @@
  */
 
 #include "api/test/simulated_network.h"
+#include "call/fake_network_pipe.h"
+#include "call/simulated_network.h"
 #include "media/engine/internalencoderfactory.h"
 #include "media/engine/simulcast_encoder_adapter.h"
 #include "modules/rtp_rtcp/source/rtp_format.h"
@@ -292,7 +294,9 @@ void PictureIdTest::SetupEncoder(VideoEncoderFactory* encoder_factory,
     send_transport_.reset(new test::PacketTransport(
         &task_queue_, sender_call_.get(), observer_.get(),
         test::PacketTransport::kSender, payload_type_map_,
-        DefaultNetworkSimulationConfig()));
+        absl::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(), absl::make_unique<SimulatedNetwork>(
+                                           DefaultNetworkSimulationConfig()))));
 
     CreateSendConfig(kNumSimulcastStreams, 0, 0, send_transport_.get());
     GetVideoSendConfig()->encoder_settings.encoder_factory = encoder_factory;
diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc
index df23a8ba60..7da9fda403 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -792,8 +792,12 @@ void VideoQualityTest::StopThumbnails() {
 std::unique_ptr<test::LayerFilteringTransport>
 VideoQualityTest::CreateSendTransport() {
   return absl::make_unique<test::LayerFilteringTransport>(
-      &task_queue_, params_.pipe, sender_call_.get(), kPayloadTypeVP8,
-      kPayloadTypeVP9, params_.video[0].selected_tl, params_.ss[0].selected_sl,
+      &task_queue_,
+      absl::make_unique<FakeNetworkPipe>(
+          Clock::GetRealTimeClock(),
+          absl::make_unique<SimulatedNetwork>(params_.pipe)),
+      sender_call_.get(), kPayloadTypeVP8, kPayloadTypeVP9,
+      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));
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index 7a2ded0e15..3baf13a178 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -13,7 +13,9 @@
 
 #include "api/test/simulated_network.h"
 #include "call/call.h"
+#include "call/fake_network_pipe.h"
 #include "call/rtp_transport_controller_send.h"
+#include "call/simulated_network.h"
 #include "common_video/include/frame_callback.h"
 #include "common_video/include/video_frame.h"
 #include "modules/rtp_rtcp/include/rtp_header_parser.h"
@@ -530,7 +532,10 @@ class UlpfecObserver : public test::EndToEndTest {
     config.queue_delay_ms = kNetworkDelayMs;
     return new test::PacketTransport(
         task_queue, sender_call, this, test::PacketTransport::kSender,
-        VideoSendStreamTest::payload_type_map_, config);
+        VideoSendStreamTest::payload_type_map_,
+        absl::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(),
+            absl::make_unique<SimulatedNetwork>(config)));
   }
 
   void ModifyVideoConfigs(
@@ -717,7 +722,10 @@ class FlexfecObserver : public test::EndToEndTest {
     config.queue_delay_ms = kNetworkDelayMs;
     return new test::PacketTransport(
         task_queue, sender_call, this, test::PacketTransport::kSender,
-        VideoSendStreamTest::payload_type_map_, config);
+        VideoSendStreamTest::payload_type_map_,
+        absl::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(),
+            absl::make_unique<SimulatedNetwork>(config)));
   }
 
   void ModifyVideoConfigs(
@@ -1460,9 +1468,12 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
       config.loss_percent = 10;
       config.link_capacity_kbps = kCapacityKbps;
       config.queue_delay_ms = kNetworkDelayMs;
-      return new test::PacketTransport(task_queue, sender_call, this,
-                                       test::PacketTransport::kSender,
-                                       payload_type_map_, config);
+      return new test::PacketTransport(
+          task_queue, sender_call, this, test::PacketTransport::kSender,
+          payload_type_map_,
+          absl::make_unique<FakeNetworkPipe>(
+              Clock::GetRealTimeClock(),
+              absl::make_unique<SimulatedNetwork>(config)));
     }
 
     void ModifyVideoConfigs(