Call OnSentPacket for all packets sent in the test framework.

Required a bit of refactoring to make it possible to pass a Call to DirectTransport on construction. This also lead to me having to remove the shared lock between PacketTransport and RtpRtcpObserver. Now RtpRtcpObserver has a SetTransports method instead of a SetReceivers method.

BUG=webrtc:4173

Review URL: https://codereview.webrtc.org/1419193002

Cr-Commit-Position: refs/heads/master@{#10430}

16 files changed, 401 insertions, 454 deletions

diff --git a/webrtc/call/bitrate_estimator_tests.cc b/webrtc/call/bitrate_estimator_tests.cc
index 08e36c893a..e327c59d9e 100644
--- a/webrtc/call/bitrate_estimator_tests.cc
+++ b/webrtc/call/bitrate_estimator_tests.cc
@@ -116,15 +116,7 @@ static const int kASTExtensionId = 5;
 
 class BitrateEstimatorTest : public test::CallTest {
  public:
-  BitrateEstimatorTest()
-      : receiver_trace_(),
-        send_transport_(),
-        receive_transport_(),
-        sender_call_(),
-        receiver_call_(),
-        receive_config_(nullptr),
-        streams_() {
-  }
+  BitrateEstimatorTest() : receive_config_(nullptr) {}
 
   virtual ~BitrateEstimatorTest() {
     EXPECT_TRUE(streams_.empty());
@@ -136,10 +128,12 @@ class BitrateEstimatorTest : public test::CallTest {
     receiver_call_.reset(Call::Create(config));
     sender_call_.reset(Call::Create(config));
 
-    send_transport_.SetReceiver(receiver_call_->Receiver());
-    receive_transport_.SetReceiver(sender_call_->Receiver());
+    send_transport_.reset(new test::DirectTransport(sender_call_.get()));
+    send_transport_->SetReceiver(receiver_call_->Receiver());
+    receive_transport_.reset(new test::DirectTransport(receiver_call_.get()));
+    receive_transport_->SetReceiver(sender_call_->Receiver());
 
-    send_config_ = VideoSendStream::Config(&send_transport_);
+    send_config_ = VideoSendStream::Config(send_transport_.get());
     send_config_.rtp.ssrcs.push_back(kSendSsrcs[0]);
     // Encoders will be set separately per stream.
     send_config_.encoder_settings.encoder = nullptr;
@@ -147,7 +141,7 @@ class BitrateEstimatorTest : public test::CallTest {
     send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
     encoder_config_.streams = test::CreateVideoStreams(1);
 
-    receive_config_ = VideoReceiveStream::Config(&receive_transport_);
+    receive_config_ = VideoReceiveStream::Config(receive_transport_.get());
     // receive_config_.decoders will be set by every stream separately.
     receive_config_.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
     receive_config_.rtp.local_ssrc = kReceiverLocalSsrc;
@@ -162,8 +156,8 @@ class BitrateEstimatorTest : public test::CallTest {
     std::for_each(streams_.begin(), streams_.end(),
         std::mem_fun(&Stream::StopSending));
 
-    send_transport_.StopSending();
-    receive_transport_.StopSending();
+    send_transport_->StopSending();
+    receive_transport_->StopSending();
 
     while (!streams_.empty()) {
       delete streams_.back();
@@ -211,8 +205,8 @@ class BitrateEstimatorTest : public test::CallTest {
         receive_config.rtp.extensions.push_back(
             RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId));
         receive_config.combined_audio_video_bwe = true;
-        audio_receive_stream_ = test_->receiver_call_->CreateAudioReceiveStream(
-            receive_config);
+        audio_receive_stream_ =
+            test_->receiver_call_->CreateAudioReceiveStream(receive_config);
       } else {
         VideoReceiveStream::Decoder decoder;
         decoder.decoder = &fake_decoder_;
@@ -270,8 +264,8 @@ class BitrateEstimatorTest : public test::CallTest {
 
   test::FakeVoiceEngine fake_voice_engine_;
   TraceObserver receiver_trace_;
-  test::DirectTransport send_transport_;
-  test::DirectTransport receive_transport_;
+  rtc::scoped_ptr<test::DirectTransport> send_transport_;
+  rtc::scoped_ptr<test::DirectTransport> receive_transport_;
   rtc::scoped_ptr<Call> sender_call_;
   rtc::scoped_ptr<Call> receiver_call_;
   VideoReceiveStream::Config receive_config_;
diff --git a/webrtc/call/call.cc b/webrtc/call/call.cc
index eda209a01e..7bb22af125 100644
--- a/webrtc/call/call.cc
+++ b/webrtc/call/call.cc
@@ -463,7 +463,6 @@ void Call::SignalNetworkState(NetworkState state) {
 }
 
 void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
-  RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   congestion_controller_->OnSentPacket(sent_packet);
 }
 
diff --git a/webrtc/call/call_perf_tests.cc b/webrtc/call/call_perf_tests.cc
index cab3914450..d9edac802e 100644
--- a/webrtc/call/call_perf_tests.cc
+++ b/webrtc/call/call_perf_tests.cc
@@ -58,8 +58,7 @@ class CallPerfTest : public test::CallTest {
 
 class SyncRtcpObserver : public test::RtpRtcpObserver {
  public:
-  explicit SyncRtcpObserver(const FakeNetworkPipe::Config& config)
-      : test::RtpRtcpObserver(CallPerfTest::kLongTimeoutMs, config) {}
+  SyncRtcpObserver() : test::RtpRtcpObserver(CallPerfTest::kLongTimeoutMs) {}
 
   Action OnSendRtcp(const uint8_t* packet, size_t length) override {
     RTCPUtility::RTCPParserV2 parser(packet, length, true);
@@ -127,8 +126,7 @@ class VideoRtcpAndSyncObserver : public SyncRtcpObserver, public VideoRenderer {
                            int voe_channel,
                            VoEVideoSync* voe_sync,
                            SyncRtcpObserver* audio_observer)
-      : SyncRtcpObserver(FakeNetworkPipe::Config()),
-        clock_(clock),
+      : clock_(clock),
         voe_channel_(voe_channel),
         voe_sync_(voe_sync),
         audio_observer_(audio_observer),
@@ -182,10 +180,10 @@ class VideoRtcpAndSyncObserver : public SyncRtcpObserver, public VideoRenderer {
 
  private:
   Clock* const clock_;
-  int voe_channel_;
-  VoEVideoSync* voe_sync_;
-  SyncRtcpObserver* audio_observer_;
-  int64_t creation_time_ms_;
+  const int voe_channel_;
+  VoEVideoSync* const voe_sync_;
+  SyncRtcpObserver* const audio_observer_;
+  const int64_t creation_time_ms_;
   int64_t first_time_in_sync_;
 };
 
@@ -232,14 +230,7 @@ void CallPerfTest::TestAudioVideoSync(bool fec, bool create_audio_first) {
   EXPECT_EQ(0, voe_base->Init(&fake_audio_device, nullptr));
   int channel = voe_base->CreateChannel();
 
-  FakeNetworkPipe::Config net_config;
-  net_config.queue_delay_ms = 500;
-  net_config.loss_percent = 5;
-  SyncRtcpObserver audio_observer(net_config);
-  VideoRtcpAndSyncObserver observer(Clock::GetRealTimeClock(),
-                                    channel,
-                                    voe_sync,
-                                    &audio_observer);
+  SyncRtcpObserver audio_observer;
 
   Call::Config receiver_config;
   receiver_config.voice_engine = voice_engine;
@@ -249,19 +240,38 @@ void CallPerfTest::TestAudioVideoSync(bool fec, bool create_audio_first) {
   EXPECT_EQ(0, voe_codec->SetSendCodec(channel, isac));
 
   AudioPacketReceiver voe_packet_receiver(channel, voe_network);
-  audio_observer.SetReceivers(&voe_packet_receiver, &voe_packet_receiver);
 
-  internal::TransportAdapter transport_adapter(audio_observer.SendTransport());
+  FakeNetworkPipe::Config net_config;
+  net_config.queue_delay_ms = 500;
+  net_config.loss_percent = 5;
+  test::PacketTransport audio_send_transport(
+      nullptr, &audio_observer, test::PacketTransport::kSender, net_config);
+  audio_send_transport.SetReceiver(&voe_packet_receiver);
+  test::PacketTransport audio_receive_transport(
+      nullptr, &audio_observer, test::PacketTransport::kReceiver, net_config);
+  audio_receive_transport.SetReceiver(&voe_packet_receiver);
+
+  internal::TransportAdapter transport_adapter(&audio_send_transport);
   transport_adapter.Enable();
   EXPECT_EQ(0,
             voe_network->RegisterExternalTransport(channel, transport_adapter));
 
-  observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
+  VideoRtcpAndSyncObserver observer(Clock::GetRealTimeClock(), channel,
+                                    voe_sync, &audio_observer);
+
+  test::PacketTransport sync_send_transport(sender_call_.get(), &observer,
+                                            test::PacketTransport::kSender,
+                                            FakeNetworkPipe::Config());
+  sync_send_transport.SetReceiver(receiver_call_->Receiver());
+  test::PacketTransport sync_receive_transport(receiver_call_.get(), &observer,
+                                               test::PacketTransport::kReceiver,
+                                               FakeNetworkPipe::Config());
+  sync_receive_transport.SetReceiver(sender_call_->Receiver());
 
   test::FakeDecoder fake_decoder;
 
-  CreateSendConfig(1, observer.SendTransport());
-  CreateMatchingReceiveConfigs(observer.ReceiveTransport());
+  CreateSendConfig(1, &sync_send_transport);
+  CreateMatchingReceiveConfigs(&sync_receive_transport);
 
   send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
   if (fec) {
@@ -308,8 +318,10 @@ void CallPerfTest::TestAudioVideoSync(bool fec, bool create_audio_first) {
   fake_audio_device.Stop();
 
   Stop();
-  observer.StopSending();
-  audio_observer.StopSending();
+  sync_send_transport.StopSending();
+  sync_receive_transport.StopSending();
+  audio_send_transport.StopSending();
+  audio_receive_transport.StopSending();
 
   voe_base->DeleteChannel(channel);
   voe_base->Release();
@@ -345,11 +357,8 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
   class CaptureNtpTimeObserver : public test::EndToEndTest,
                                  public VideoRenderer {
    public:
-    CaptureNtpTimeObserver(const FakeNetworkPipe::Config& config,
-                           int threshold_ms,
-                           int start_time_ms,
-                           int run_time_ms)
-        : EndToEndTest(kLongTimeoutMs, config),
+    CaptureNtpTimeObserver(int threshold_ms, int start_time_ms, int run_time_ms)
+        : EndToEndTest(kLongTimeoutMs),
           clock_(Clock::GetRealTimeClock()),
           threshold_ms_(threshold_ms),
           start_time_ms_(start_time_ms),
@@ -362,6 +371,7 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
    private:
     void RenderFrame(const VideoFrame& video_frame,
                      int time_to_render_ms) override {
+      rtc::CritScope lock(&crit_);
       if (video_frame.ntp_time_ms() <= 0) {
         // Haven't got enough RTCP SR in order to calculate the capture ntp
         // time.
@@ -402,6 +412,7 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
     bool IsTextureSupported() const override { return false; }
 
     virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
+      rtc::CritScope lock(&crit_);
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
@@ -440,7 +451,8 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
                                            "within bounds.";
     }
 
-    Clock* clock_;
+    rtc::CriticalSection crit_;
+    Clock* const clock_;
     int threshold_ms_;
     int start_time_ms_;
     int run_time_ms_;
@@ -449,10 +461,10 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
     bool rtp_start_timestamp_set_;
     uint32_t rtp_start_timestamp_;
     typedef std::map<uint32_t, uint32_t> FrameCaptureTimeList;
-    FrameCaptureTimeList capture_time_list_;
-  } test(net_config, threshold_ms, start_time_ms, run_time_ms);
+    FrameCaptureTimeList capture_time_list_ GUARDED_BY(&crit_);
+  } test(threshold_ms, start_time_ms, run_time_ms);
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, net_config);
 }
 
 TEST_F(CallPerfTest, CaptureNtpTimeWithNetworkDelay) {
@@ -508,7 +520,7 @@ void CallPerfTest::TestCpuOveruse(LoadObserver::Load tested_load,
     test::DelayedEncoder encoder_;
   } test(tested_load, encode_delay_ms);
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(CallPerfTest, ReceivesCpuUnderuse) {
@@ -528,26 +540,17 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
   static const int kMaxAcceptableTransmitBitrate = 170;
   static const int kNumBitrateObservationsInRange = 100;
   static const int kAcceptableBitrateErrorMargin = 15;  // +- 7
-  class BitrateObserver : public test::EndToEndTest, public PacketReceiver {
+  class BitrateObserver : public test::EndToEndTest {
    public:
     explicit BitrateObserver(bool using_min_transmit_bitrate)
         : EndToEndTest(kLongTimeoutMs),
           send_stream_(nullptr),
-          send_transport_receiver_(nullptr),
           pad_to_min_bitrate_(using_min_transmit_bitrate),
           num_bitrate_observations_in_range_(0) {}
 
    private:
-    void SetReceivers(PacketReceiver* send_transport_receiver,
-                      PacketReceiver* receive_transport_receiver) override {
-      send_transport_receiver_ = send_transport_receiver;
-      test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver);
-    }
-
-    DeliveryStatus DeliverPacket(MediaType media_type,
-                                 const uint8_t* packet,
-                                 size_t length,
-                                 const PacketTime& packet_time) override {
+    // TODO(holmer): Run this with a timer instead of once per packet.
+    Action OnSendRtp(const uint8_t* packet, size_t length) override {
       VideoSendStream::Stats stats = send_stream_->GetStats();
       if (stats.substreams.size() > 0) {
         RTC_DCHECK_EQ(1u, stats.substreams.size());
@@ -581,8 +584,7 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
             observation_complete_->Set();
         }
       }
-      return send_transport_receiver_->DeliverPacket(media_type, packet, length,
-                                                     packet_time);
+      return SEND_PACKET;
     }
 
     void OnStreamsCreated(
@@ -607,13 +609,12 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
     }
 
     VideoSendStream* send_stream_;
-    PacketReceiver* send_transport_receiver_;
     const bool pad_to_min_bitrate_;
     int num_bitrate_observations_in_range_;
   } test(pad_to_min_bitrate);
 
   fake_encoder_.SetMaxBitrate(kMaxEncodeBitrateKbps);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(CallPerfTest, PadsToMinTransmitBitrate) { TestMinTransmitBitrate(true); }
@@ -708,7 +709,7 @@ TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) {
     VideoEncoderConfig encoder_config_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 }  // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
index 342486e7d8..61ed512e64 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
@@ -680,13 +680,13 @@ size_t RTPSender::SendPadData(size_t bytes,
           UpdateTransportSequenceNumber(padding_packet, length, rtp_header);
     }
 
-    if (!SendPacketToNetwork(padding_packet, length, options))
-      break;
-
     if (using_transport_seq && transport_feedback_observer_) {
       transport_feedback_observer_->AddPacket(options.packet_id, length, true);
     }
 
+    if (!SendPacketToNetwork(padding_packet, length, options))
+      break;
+
     bytes_sent += padding_bytes_in_packet;
     UpdateRtpStats(padding_packet, length, rtp_header, over_rtx, false);
   }
@@ -940,14 +940,15 @@ bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
         UpdateTransportSequenceNumber(buffer_to_send_ptr, length, rtp_header);
   }
 
+  if (using_transport_seq && transport_feedback_observer_) {
+    transport_feedback_observer_->AddPacket(options.packet_id, length, true);
+  }
+
   bool ret = SendPacketToNetwork(buffer_to_send_ptr, length, options);
   if (ret) {
     CriticalSectionScoped lock(send_critsect_.get());
     media_has_been_sent_ = true;
   }
-  if (using_transport_seq && transport_feedback_observer_) {
-    transport_feedback_observer_->AddPacket(options.packet_id, length, true);
-  }
   UpdateRtpStats(buffer_to_send_ptr, length, rtp_header, send_over_rtx,
                  is_retransmit);
   return ret;
diff --git a/webrtc/test/call_test.cc b/webrtc/test/call_test.cc
index f2b5f91c7b..7d73f154a3 100644
--- a/webrtc/test/call_test.cc
+++ b/webrtc/test/call_test.cc
@@ -27,22 +27,30 @@ CallTest::CallTest()
 CallTest::~CallTest() {
 }
 
-void CallTest::RunBaseTest(BaseTest* test) {
+void CallTest::RunBaseTest(BaseTest* test,
+                           const FakeNetworkPipe::Config& config) {
   CreateSenderCall(test->GetSenderCallConfig());
   if (test->ShouldCreateReceivers())
     CreateReceiverCall(test->GetReceiverCallConfig());
+  send_transport_.reset(new PacketTransport(
+      sender_call_.get(), test, test::PacketTransport::kSender, config));
+  receive_transport_.reset(new PacketTransport(
+      nullptr, test, test::PacketTransport::kReceiver, config));
+  test->OnTransportsCreated(send_transport_.get(), receive_transport_.get());
   test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
 
   if (test->ShouldCreateReceivers()) {
-    test->SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
+    send_transport_->SetReceiver(receiver_call_->Receiver());
+    receive_transport_->SetReceiver(sender_call_->Receiver());
   } else {
     // Sender-only call delivers to itself.
-    test->SetReceivers(sender_call_->Receiver(), NULL);
+    send_transport_->SetReceiver(sender_call_->Receiver());
+    receive_transport_->SetReceiver(nullptr);
   }
 
-  CreateSendConfig(test->GetNumStreams(), test->SendTransport());
+  CreateSendConfig(test->GetNumStreams(), send_transport_.get());
   if (test->ShouldCreateReceivers()) {
-    CreateMatchingReceiveConfigs(test->ReceiveTransport());
+    CreateMatchingReceiveConfigs(receive_transport_.get());
   }
   test->ModifyConfigs(&send_config_, &receive_configs_, &encoder_config_);
   CreateStreams();
@@ -53,7 +61,8 @@ void CallTest::RunBaseTest(BaseTest* test) {
 
   Start();
   test->PerformTest();
-  test->StopSending();
+  send_transport_->StopSending();
+  receive_transport_->StopSending();
   Stop();
 
   DestroyStreams();
@@ -182,11 +191,6 @@ const int CallTest::kAbsSendTimeExtensionId = 7;
 BaseTest::BaseTest(unsigned int timeout_ms) : RtpRtcpObserver(timeout_ms) {
 }
 
-BaseTest::BaseTest(unsigned int timeout_ms,
-                   const FakeNetworkPipe::Config& config)
-    : RtpRtcpObserver(timeout_ms, config) {
-}
-
 BaseTest::~BaseTest() {
 }
 
@@ -201,6 +205,9 @@ Call::Config BaseTest::GetReceiverCallConfig() {
 void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {
 }
 
+void BaseTest::OnTransportsCreated(PacketTransport* send_transport,
+                                   PacketTransport* receive_transport) {}
+
 size_t BaseTest::GetNumStreams() const {
   return 1;
 }
@@ -223,11 +230,6 @@ void BaseTest::OnFrameGeneratorCapturerCreated(
 SendTest::SendTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
 }
 
-SendTest::SendTest(unsigned int timeout_ms,
-                   const FakeNetworkPipe::Config& config)
-    : BaseTest(timeout_ms, config) {
-}
-
 bool SendTest::ShouldCreateReceivers() const {
   return false;
 }
@@ -235,11 +237,6 @@ bool SendTest::ShouldCreateReceivers() const {
 EndToEndTest::EndToEndTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
 }
 
-EndToEndTest::EndToEndTest(unsigned int timeout_ms,
-                           const FakeNetworkPipe::Config& config)
-    : BaseTest(timeout_ms, config) {
-}
-
 bool EndToEndTest::ShouldCreateReceivers() const {
   return true;
 }
diff --git a/webrtc/test/call_test.h b/webrtc/test/call_test.h
index 4a645b4cfd..d80d819859 100644
--- a/webrtc/test/call_test.h
+++ b/webrtc/test/call_test.h
@@ -46,7 +46,7 @@ class CallTest : public ::testing::Test {
   static const int kAbsSendTimeExtensionId;
 
  protected:
-  void RunBaseTest(BaseTest* test);
+  void RunBaseTest(BaseTest* test, const FakeNetworkPipe::Config& config);
 
   void CreateCalls(const Call::Config& sender_config,
                    const Call::Config& receiver_config);
@@ -67,11 +67,13 @@ class CallTest : public ::testing::Test {
   Clock* const clock_;
 
   rtc::scoped_ptr<Call> sender_call_;
+  rtc::scoped_ptr<PacketTransport> send_transport_;
   VideoSendStream::Config send_config_;
   VideoEncoderConfig encoder_config_;
   VideoSendStream* send_stream_;
 
   rtc::scoped_ptr<Call> receiver_call_;
+  rtc::scoped_ptr<PacketTransport> receive_transport_;
   std::vector<VideoReceiveStream::Config> receive_configs_;
   std::vector<VideoReceiveStream*> receive_streams_;
 
@@ -83,7 +85,6 @@ class CallTest : public ::testing::Test {
 class BaseTest : public RtpRtcpObserver {
  public:
   explicit BaseTest(unsigned int timeout_ms);
-  BaseTest(unsigned int timeout_ms, const FakeNetworkPipe::Config& config);
   virtual ~BaseTest();
 
   virtual void PerformTest() = 0;
@@ -94,6 +95,8 @@ class BaseTest : public RtpRtcpObserver {
   virtual Call::Config GetSenderCallConfig();
   virtual Call::Config GetReceiverCallConfig();
   virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
+  virtual void OnTransportsCreated(PacketTransport* send_transport,
+                                   PacketTransport* receive_transport);
 
   virtual void ModifyConfigs(
       VideoSendStream::Config* send_config,
@@ -110,7 +113,6 @@ class BaseTest : public RtpRtcpObserver {
 class SendTest : public BaseTest {
  public:
   explicit SendTest(unsigned int timeout_ms);
-  SendTest(unsigned int timeout_ms, const FakeNetworkPipe::Config& config);
 
   bool ShouldCreateReceivers() const override;
 };
@@ -118,7 +120,6 @@ class SendTest : public BaseTest {
 class EndToEndTest : public BaseTest {
  public:
   explicit EndToEndTest(unsigned int timeout_ms);
-  EndToEndTest(unsigned int timeout_ms, const FakeNetworkPipe::Config& config);
 
   bool ShouldCreateReceivers() const override;
 };
diff --git a/webrtc/test/direct_transport.cc b/webrtc/test/direct_transport.cc
index 1f92e92357..ac56ec3828 100644
--- a/webrtc/test/direct_transport.cc
+++ b/webrtc/test/direct_transport.cc
@@ -17,8 +17,9 @@
 namespace webrtc {
 namespace test {
 
-DirectTransport::DirectTransport()
-    : packet_event_(EventWrapper::Create()),
+DirectTransport::DirectTransport(Call* send_call)
+    : send_call_(send_call),
+      packet_event_(EventWrapper::Create()),
       thread_(
           ThreadWrapper::CreateThread(NetworkProcess, this, "NetworkProcess")),
       clock_(Clock::GetRealTimeClock()),
@@ -27,8 +28,10 @@ DirectTransport::DirectTransport()
   EXPECT_TRUE(thread_->Start());
 }
 
-DirectTransport::DirectTransport(const FakeNetworkPipe::Config& config)
-    : packet_event_(EventWrapper::Create()),
+DirectTransport::DirectTransport(const FakeNetworkPipe::Config& config,
+                                 Call* send_call)
+    : send_call_(send_call),
+      packet_event_(EventWrapper::Create()),
       thread_(
           ThreadWrapper::CreateThread(NetworkProcess, this, "NetworkProcess")),
       clock_(Clock::GetRealTimeClock()),
@@ -60,6 +63,11 @@ void DirectTransport::SetReceiver(PacketReceiver* receiver) {
 bool DirectTransport::SendRtp(const uint8_t* data,
                               size_t length,
                               const PacketOptions& options) {
+  if (send_call_) {
+    rtc::SentPacket sent_packet(options.packet_id,
+                                clock_->TimeInMilliseconds());
+    send_call_->OnSentPacket(sent_packet);
+  }
   fake_network_.SendPacket(data, length);
   packet_event_->Set();
   return true;
diff --git a/webrtc/test/direct_transport.h b/webrtc/test/direct_transport.h
index 1c6f937401..f910efafaf 100644
--- a/webrtc/test/direct_transport.h
+++ b/webrtc/test/direct_transport.h
@@ -23,6 +23,7 @@
 
 namespace webrtc {
 
+class Call;
 class Clock;
 class PacketReceiver;
 
@@ -30,13 +31,14 @@ namespace test {
 
 class DirectTransport : public Transport {
  public:
-  DirectTransport();
-  explicit DirectTransport(const FakeNetworkPipe::Config& config);
+  explicit DirectTransport(Call* send_call);
+  DirectTransport(const FakeNetworkPipe::Config& config, Call* send_call);
   ~DirectTransport();
 
   void SetConfig(const FakeNetworkPipe::Config& config);
 
   virtual void StopSending();
+  // TODO(holmer): Look into moving this to the constructor.
   virtual void SetReceiver(PacketReceiver* receiver);
 
   bool SendRtp(const uint8_t* data,
@@ -49,6 +51,7 @@ class DirectTransport : public Transport {
   bool SendPackets();
 
   rtc::CriticalSection lock_;
+  Call* const send_call_;
   rtc::scoped_ptr<EventWrapper> packet_event_;
   rtc::scoped_ptr<ThreadWrapper> thread_;
   Clock* const clock_;
diff --git a/webrtc/test/layer_filtering_transport.cc b/webrtc/test/layer_filtering_transport.cc
index b9bc24d3ee..a4ebf47f93 100644
--- a/webrtc/test/layer_filtering_transport.cc
+++ b/webrtc/test/layer_filtering_transport.cc
@@ -21,16 +21,16 @@ namespace test {
 
 LayerFilteringTransport::LayerFilteringTransport(
     const FakeNetworkPipe::Config& config,
+    Call* send_call,
     uint8_t vp8_video_payload_type,
     uint8_t vp9_video_payload_type,
     uint8_t tl_discard_threshold,
     uint8_t sl_discard_threshold)
-    : test::DirectTransport(config),
+    : test::DirectTransport(config, send_call),
       vp8_video_payload_type_(vp8_video_payload_type),
       vp9_video_payload_type_(vp9_video_payload_type),
       tl_discard_threshold_(tl_discard_threshold),
-      sl_discard_threshold_(sl_discard_threshold) {
-}
+      sl_discard_threshold_(sl_discard_threshold) {}
 
 uint16_t LayerFilteringTransport::NextSequenceNumber(uint32_t ssrc) {
   auto it = current_seq_nums_.find(ssrc);
diff --git a/webrtc/test/layer_filtering_transport.h b/webrtc/test/layer_filtering_transport.h
index 58c2dd566b..3f2389a51b 100644
--- a/webrtc/test/layer_filtering_transport.h
+++ b/webrtc/test/layer_filtering_transport.h
@@ -10,6 +10,7 @@
 #ifndef WEBRTC_TEST_LAYER_FILTERING_TRANSPORT_H_
 #define WEBRTC_TEST_LAYER_FILTERING_TRANSPORT_H_
 
+#include "webrtc/call.h"
 #include "webrtc/test/direct_transport.h"
 #include "webrtc/test/fake_network_pipe.h"
 
@@ -22,6 +23,7 @@ namespace test {
 class LayerFilteringTransport : public test::DirectTransport {
  public:
   LayerFilteringTransport(const FakeNetworkPipe::Config& config,
+                          Call* send_call,
                           uint8_t vp8_video_payload_type,
                           uint8_t vp9_video_payload_type,
                           uint8_t tl_discard_threshold,
diff --git a/webrtc/test/rtp_rtcp_observer.h b/webrtc/test/rtp_rtcp_observer.h
index 97aa7b689e..50fd86485f 100644
--- a/webrtc/test/rtp_rtcp_observer.h
+++ b/webrtc/test/rtp_rtcp_observer.h
@@ -24,159 +24,108 @@
 namespace webrtc {
 namespace test {
 
+class PacketTransport;
+
 class RtpRtcpObserver {
  public:
+  enum Action {
+    SEND_PACKET,
+    DROP_PACKET,
+  };
+
   virtual ~RtpRtcpObserver() {}
-  Transport* SendTransport() {
-    return &send_transport_;
+
+  virtual EventTypeWrapper Wait() {
+    EventTypeWrapper result = observation_complete_->Wait(timeout_ms_);
+    return result;
   }
 
-  Transport* ReceiveTransport() {
-    return &receive_transport_;
+  virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
+    return SEND_PACKET;
   }
 
-  virtual void SetReceivers(PacketReceiver* send_transport_receiver,
-                            PacketReceiver* receive_transport_receiver) {
-    send_transport_.SetReceiver(send_transport_receiver);
-    receive_transport_.SetReceiver(receive_transport_receiver);
+  virtual Action OnSendRtcp(const uint8_t* packet, size_t length) {
+    return SEND_PACKET;
   }
 
-  void StopSending() {
-    send_transport_.StopSending();
-    receive_transport_.StopSending();
+  virtual Action OnReceiveRtp(const uint8_t* packet, size_t length) {
+    return SEND_PACKET;
   }
 
-  virtual EventTypeWrapper Wait() {
-    EventTypeWrapper result = observation_complete_->Wait(timeout_ms_);
-    return result;
+  virtual Action OnReceiveRtcp(const uint8_t* packet, size_t length) {
+    return SEND_PACKET;
   }
 
  protected:
-  RtpRtcpObserver(unsigned int event_timeout_ms,
-                  const FakeNetworkPipe::Config& configuration)
-      : observation_complete_(EventWrapper::Create()),
-        parser_(RtpHeaderParser::Create()),
-        send_transport_(&crit_,
-                        this,
-                        &RtpRtcpObserver::OnSendRtp,
-                        &RtpRtcpObserver::OnSendRtcp,
-                        configuration),
-        receive_transport_(&crit_,
-                           this,
-                           &RtpRtcpObserver::OnReceiveRtp,
-                           &RtpRtcpObserver::OnReceiveRtcp,
-                           configuration),
-        timeout_ms_(event_timeout_ms) {}
-
   explicit RtpRtcpObserver(unsigned int event_timeout_ms)
       : observation_complete_(EventWrapper::Create()),
         parser_(RtpHeaderParser::Create()),
-        send_transport_(&crit_,
-                        this,
-                        &RtpRtcpObserver::OnSendRtp,
-                        &RtpRtcpObserver::OnSendRtcp,
-                        FakeNetworkPipe::Config()),
-        receive_transport_(&crit_,
-                           this,
-                           &RtpRtcpObserver::OnReceiveRtp,
-                           &RtpRtcpObserver::OnReceiveRtcp,
-                           FakeNetworkPipe::Config()),
         timeout_ms_(event_timeout_ms) {}
 
-  enum Action {
-    SEND_PACKET,
-    DROP_PACKET,
-  };
-
-  virtual Action OnSendRtp(const uint8_t* packet, size_t length)
-      EXCLUSIVE_LOCKS_REQUIRED(crit_) {
-    return SEND_PACKET;
-  }
+  const rtc::scoped_ptr<EventWrapper> observation_complete_;
+  const rtc::scoped_ptr<RtpHeaderParser> parser_;
 
-  virtual Action OnSendRtcp(const uint8_t* packet, size_t length)
-      EXCLUSIVE_LOCKS_REQUIRED(crit_) {
-    return SEND_PACKET;
-  }
+ private:
+  unsigned int timeout_ms_;
+};
 
-  virtual Action OnReceiveRtp(const uint8_t* packet, size_t length)
-      EXCLUSIVE_LOCKS_REQUIRED(crit_) {
-    return SEND_PACKET;
-  }
+class PacketTransport : public test::DirectTransport {
+ public:
+  enum TransportType { kReceiver, kSender };
 
-  virtual Action OnReceiveRtcp(const uint8_t* packet, size_t length)
-      EXCLUSIVE_LOCKS_REQUIRED(crit_) {
-    return SEND_PACKET;
-  }
+  PacketTransport(Call* send_call,
+                  RtpRtcpObserver* observer,
+                  TransportType transport_type,
+                  const FakeNetworkPipe::Config& configuration)
+      : test::DirectTransport(configuration, send_call),
+        observer_(observer),
+        transport_type_(transport_type) {}
 
  private:
-  class PacketTransport : public test::DirectTransport {
-   public:
-    typedef Action (RtpRtcpObserver::*PacketTransportAction)(const uint8_t*,
-                                                             size_t);
-
-    PacketTransport(rtc::CriticalSection* lock,
-                    RtpRtcpObserver* observer,
-                    PacketTransportAction on_rtp,
-                    PacketTransportAction on_rtcp,
-                    const FakeNetworkPipe::Config& configuration)
-        : test::DirectTransport(configuration),
-          crit_(lock),
-          observer_(observer),
-          on_rtp_(on_rtp),
-          on_rtcp_(on_rtcp) {}
-
-  private:
-   bool SendRtp(const uint8_t* packet,
-                size_t length,
-                const PacketOptions& options) override {
-      EXPECT_FALSE(RtpHeaderParser::IsRtcp(packet, length));
-      Action action;
-      {
-        rtc::CritScope lock(crit_);
-        action = (observer_->*on_rtp_)(packet, length);
-      }
-      switch (action) {
-        case DROP_PACKET:
-          // Drop packet silently.
-          return true;
-        case SEND_PACKET:
-          return test::DirectTransport::SendRtp(packet, length, options);
+  bool SendRtp(const uint8_t* packet,
+               size_t length,
+               const PacketOptions& options) override {
+    EXPECT_FALSE(RtpHeaderParser::IsRtcp(packet, length));
+    RtpRtcpObserver::Action action;
+    {
+      if (transport_type_ == kSender) {
+        action = observer_->OnSendRtp(packet, length);
+      } else {
+        action = observer_->OnReceiveRtp(packet, length);
       }
-      return true;  // Will never happen, makes compiler happy.
     }
+    switch (action) {
+      case RtpRtcpObserver::DROP_PACKET:
+        // Drop packet silently.
+        return true;
+      case RtpRtcpObserver::SEND_PACKET:
+        return test::DirectTransport::SendRtp(packet, length, options);
+    }
+    return true;  // Will never happen, makes compiler happy.
+  }
 
-    bool SendRtcp(const uint8_t* packet, size_t length) override {
-      EXPECT_TRUE(RtpHeaderParser::IsRtcp(packet, length));
-      Action action;
-      {
-        rtc::CritScope lock(crit_);
-        action = (observer_->*on_rtcp_)(packet, length);
+  bool SendRtcp(const uint8_t* packet, size_t length) override {
+    EXPECT_TRUE(RtpHeaderParser::IsRtcp(packet, length));
+    RtpRtcpObserver::Action action;
+    {
+      if (transport_type_ == kSender) {
+        action = observer_->OnSendRtcp(packet, length);
+      } else {
+        action = observer_->OnReceiveRtcp(packet, length);
       }
-      switch (action) {
-        case DROP_PACKET:
-          // Drop packet silently.
-          return true;
-        case SEND_PACKET:
-          return test::DirectTransport::SendRtcp(packet, length);
-      }
-      return true;  // Will never happen, makes compiler happy.
     }
+    switch (action) {
+      case RtpRtcpObserver::DROP_PACKET:
+        // Drop packet silently.
+        return true;
+      case RtpRtcpObserver::SEND_PACKET:
+        return test::DirectTransport::SendRtcp(packet, length);
+    }
+    return true;  // Will never happen, makes compiler happy.
+  }
 
-    // Pointer to shared lock instance protecting on_rtp_/on_rtcp_ calls.
-    rtc::CriticalSection* const crit_;
-
-    RtpRtcpObserver* const observer_;
-    const PacketTransportAction on_rtp_, on_rtcp_;
-  };
-
- protected:
-  rtc::CriticalSection crit_;
-  const rtc::scoped_ptr<EventWrapper> observation_complete_;
-  const rtc::scoped_ptr<RtpHeaderParser> parser_;
-  PacketTransport send_transport_, receive_transport_;
-
- private:
-  unsigned int timeout_ms_;
+  RtpRtcpObserver* const observer_;
+  TransportType transport_type_;
 };
 }  // namespace test
 }  // namespace webrtc
diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc
index 31ec7d5a76..c57b8a1c02 100644
--- a/webrtc/video/end_to_end_tests.cc
+++ b/webrtc/video/end_to_end_tests.cc
@@ -81,7 +81,6 @@ class EndToEndTest : public test::CallTest {
   void TestXrReceiverReferenceTimeReport(bool enable_rrtr);
   void TestSendsSetSsrcs(size_t num_ssrcs, bool send_single_ssrc_first);
   void TestRtpStatePreservation(bool use_rtx);
-  void TestReceivedFecPacketsNotNacked(const FakeNetworkPipe::Config& config);
   void VerifyHistogramStats(bool use_rtx, bool use_red);
 };
 
@@ -156,7 +155,8 @@ TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
 
   CreateCalls(Call::Config(), Call::Config());
 
-  test::DirectTransport sender_transport, receiver_transport;
+  test::DirectTransport sender_transport(sender_call_.get());
+  test::DirectTransport receiver_transport(receiver_call_.get());
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
@@ -206,7 +206,8 @@ TEST_F(EndToEndTest, TransmitsFirstFrame) {
 
   CreateCalls(Call::Config(), Call::Config());
 
-  test::DirectTransport sender_transport, receiver_transport;
+  test::DirectTransport sender_transport(sender_call_.get());
+  test::DirectTransport receiver_transport(receiver_call_.get());
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
@@ -281,7 +282,7 @@ TEST_F(EndToEndTest, SendsAndReceivesVP9) {
     int frame_counter_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, SendsAndReceivesH264) {
@@ -333,7 +334,7 @@ TEST_F(EndToEndTest, SendsAndReceivesH264) {
     int frame_counter_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) {
@@ -361,7 +362,7 @@ TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) {
     }
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
@@ -379,6 +380,7 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
+      rtc::CritScope lock(&crit_);
       RTPHeader header;
       EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header));
 
@@ -414,6 +416,7 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
     }
 
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
+      rtc::CritScope lock(&crit_);
       RTCPUtility::RTCPParserV2 parser(packet, length, true);
       EXPECT_TRUE(parser.IsValid());
 
@@ -441,15 +444,16 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
              "rendered.";
     }
 
+    rtc::CriticalSection crit_;
     rtc::scoped_ptr<RtpHeaderParser> rtp_parser_;
     std::set<uint16_t> dropped_packets_;
     std::set<uint16_t> retransmitted_packets_;
     uint64_t sent_rtp_packets_;
     int packets_left_to_drop_;
-    int nacks_left_;
+    int nacks_left_ GUARDED_BY(&crit_);
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, CanReceiveFec) {
@@ -459,8 +463,8 @@ TEST_F(EndToEndTest, CanReceiveFec) {
         : EndToEndTest(kDefaultTimeoutMs), state_(kFirstPacket) {}
 
    private:
-    Action OnSendRtp(const uint8_t* packet, size_t length) override
-        EXCLUSIVE_LOCKS_REQUIRED(crit_) {
+    Action OnSendRtp(const uint8_t* packet, size_t length) override {
+      rtc::CritScope lock(&crit_);
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
@@ -544,29 +548,20 @@ TEST_F(EndToEndTest, CanReceiveFec) {
           << "Timed out waiting for dropped frames frames to be rendered.";
     }
 
+    rtc::CriticalSection crit_;
     std::set<uint32_t> protected_sequence_numbers_ GUARDED_BY(crit_);
     std::set<uint32_t> protected_timestamps_ GUARDED_BY(crit_);
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 // Flacky on all platforms. See webrtc:4328.
 TEST_F(EndToEndTest, DISABLED_ReceivedFecPacketsNotNacked) {
-  // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
-  // Configure some network delay.
-  const int kNetworkDelayMs = 50;
-  FakeNetworkPipe::Config config;
-  config.queue_delay_ms = kNetworkDelayMs;
-  TestReceivedFecPacketsNotNacked(config);
-}
-
-void EndToEndTest::TestReceivedFecPacketsNotNacked(
-    const FakeNetworkPipe::Config& config) {
   class FecNackObserver : public test::EndToEndTest {
    public:
-    explicit FecNackObserver(const FakeNetworkPipe::Config& config)
-        : EndToEndTest(kDefaultTimeoutMs, config),
+    explicit FecNackObserver()
+        : EndToEndTest(kDefaultTimeoutMs),
           state_(kFirstPacket),
           fec_sequence_number_(0),
           has_last_sequence_number_(false),
@@ -674,9 +669,14 @@ void EndToEndTest::TestReceivedFecPacketsNotNacked(
     uint16_t fec_sequence_number_;
     bool has_last_sequence_number_;
     uint16_t last_sequence_number_;
-  } test(config);
+  } test;
 
-  RunBaseTest(&test);
+  // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
+  // Configure some network delay.
+  const int kNetworkDelayMs = 50;
+  FakeNetworkPipe::Config config;
+  config.queue_delay_ms = kNetworkDelayMs;
+  RunBaseTest(&test, config);
 }
 
 // This test drops second RTP packet with a marker bit set, makes sure it's
@@ -700,6 +700,7 @@ void EndToEndTest::DecodesRetransmittedFrame(bool use_rtx, bool use_red) {
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
+      rtc::CritScope lock(&crit_);
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
@@ -773,16 +774,17 @@ void EndToEndTest::DecodesRetransmittedFrame(bool use_rtx, bool use_red) {
                      : (use_red ? kRedPayloadType : kFakeSendPayloadType);
     }
 
+    rtc::CriticalSection crit_;
     const int payload_type_;
     const uint32_t retransmission_ssrc_;
     const int retransmission_payload_type_;
     int marker_bits_observed_;
     int num_packets_observed_;
-    uint32_t retransmitted_timestamp_;
+    uint32_t retransmitted_timestamp_ GUARDED_BY(&crit_);
     bool frame_retransmitted_;
   } test(use_rtx, use_red);
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, DecodesRetransmittedFrame) {
@@ -861,7 +863,8 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) {
 
   CreateCalls(Call::Config(), Call::Config());
 
-  test::DirectTransport sender_transport, receiver_transport;
+  test::DirectTransport sender_transport(sender_call_.get());
+  test::DirectTransport receiver_transport(receiver_call_.get());
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
@@ -918,6 +921,7 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
+      rtc::CritScope lock(&crit_);
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
@@ -935,6 +939,7 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
     }
 
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
+      rtc::CritScope lock(&crit_);
       RTCPUtility::RTCPParserV2 parser(packet, length, true);
       EXPECT_TRUE(parser.IsValid());
 
@@ -979,14 +984,15 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
                                            "rendered afterwards.";
     }
 
+    rtc::CriticalSection crit_;
     int rtp_history_ms_;
     bool nack_enabled_;
-    uint32_t highest_dropped_timestamp_;
-    int frames_to_drop_;
-    bool received_pli_;
+    uint32_t highest_dropped_timestamp_ GUARDED_BY(&crit_);
+    int frames_to_drop_ GUARDED_BY(&crit_);
+    bool received_pli_ GUARDED_BY(&crit_);
   } test(rtp_history_ms);
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, ReceivesPliAndRecoversWithNack) {
@@ -1031,7 +1037,8 @@ TEST_F(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
 
   CreateCalls(Call::Config(), Call::Config());
 
-  test::DirectTransport send_transport, receive_transport;
+  test::DirectTransport send_transport(sender_call_.get());
+  test::DirectTransport receive_transport(receiver_call_.get());
   PacketInputObserver input_observer(receiver_call_->Receiver());
   send_transport.SetReceiver(&input_observer);
   receive_transport.SetReceiver(sender_call_->Receiver());
@@ -1135,7 +1142,7 @@ void EndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) {
     int sent_rtcp_;
   } test(rtcp_mode);
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, UsesRtcpCompoundMode) {
@@ -1167,13 +1174,12 @@ class MultiStreamTest {
   virtual ~MultiStreamTest() {}
 
   void RunTest() {
-    rtc::scoped_ptr<test::DirectTransport> sender_transport(
-        CreateSendTransport());
-    rtc::scoped_ptr<test::DirectTransport> receiver_transport(
-        CreateReceiveTransport());
-
     rtc::scoped_ptr<Call> sender_call(Call::Create(Call::Config()));
     rtc::scoped_ptr<Call> receiver_call(Call::Create(Call::Config()));
+    rtc::scoped_ptr<test::DirectTransport> sender_transport(
+        CreateSendTransport(sender_call.get()));
+    rtc::scoped_ptr<test::DirectTransport> receiver_transport(
+        CreateReceiveTransport(receiver_call.get()));
     sender_transport->SetReceiver(receiver_call->Receiver());
     receiver_transport->SetReceiver(sender_call->Receiver());
 
@@ -1257,11 +1263,11 @@ class MultiStreamTest {
   virtual void UpdateReceiveConfig(size_t stream_index,
                                    VideoReceiveStream::Config* receive_config) {
   }
-  virtual test::DirectTransport* CreateSendTransport() {
-    return new test::DirectTransport();
+  virtual test::DirectTransport* CreateSendTransport(Call* sender_call) {
+    return new test::DirectTransport(sender_call);
   }
-  virtual test::DirectTransport* CreateReceiveTransport() {
-    return new test::DirectTransport();
+  virtual test::DirectTransport* CreateReceiveTransport(Call* receiver_call) {
+    return new test::DirectTransport(receiver_call);
   }
 };
 
@@ -1340,9 +1346,11 @@ TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
 
   class RtpExtensionHeaderObserver : public test::DirectTransport {
    public:
-    RtpExtensionHeaderObserver(const uint32_t& first_media_ssrc,
+    RtpExtensionHeaderObserver(Call* sender_call,
+                               const uint32_t& first_media_ssrc,
                                const std::map<uint32_t, uint32_t>& ssrc_map)
-        : done_(EventWrapper::Create()),
+        : DirectTransport(sender_call),
+          done_(EventWrapper::Create()),
           parser_(RtpHeaderParser::Create()),
           first_media_ssrc_(first_media_ssrc),
           rtx_to_media_ssrcs_(ssrc_map),
@@ -1507,8 +1515,8 @@ TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
           RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId));
     }
 
-    virtual test::DirectTransport* CreateSendTransport() {
-      observer_ = new RtpExtensionHeaderObserver(first_media_ssrc_,
+    test::DirectTransport* CreateSendTransport(Call* sender_call) override {
+      observer_ = new RtpExtensionHeaderObserver(sender_call, first_media_ssrc_,
                                                  rtx_to_media_ssrcs_);
       return observer_;
     }
@@ -1527,7 +1535,8 @@ TEST_F(EndToEndTest, ReceivesTransportFeedback) {
 
   class TransportFeedbackObserver : public test::DirectTransport {
    public:
-    TransportFeedbackObserver(rtc::Event* done_event) : done_(done_event) {}
+    TransportFeedbackObserver(Call* receiver_call, rtc::Event* done_event)
+        : DirectTransport(receiver_call), done_(done_event) {}
     virtual ~TransportFeedbackObserver() {}
 
     bool SendRtcp(const uint8_t* data, size_t length) override {
@@ -1575,8 +1584,9 @@ TEST_F(EndToEndTest, ReceivesTransportFeedback) {
           RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId));
     }
 
-    virtual test::DirectTransport* CreateReceiveTransport() {
-      return new TransportFeedbackObserver(&done_);
+    test::DirectTransport* CreateReceiveTransport(
+        Call* receiver_call) override {
+      return new TransportFeedbackObserver(receiver_call, &done_);
     }
 
    private:
@@ -1624,7 +1634,8 @@ TEST_F(EndToEndTest, ObserversEncodedFrames) {
 
   CreateCalls(Call::Config(), Call::Config());
 
-  test::DirectTransport sender_transport, receiver_transport;
+  test::DirectTransport sender_transport(sender_call_.get());
+  test::DirectTransport receiver_transport(receiver_call_.get());
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
@@ -1694,11 +1705,11 @@ TEST_F(EndToEndTest, ReceiveStreamSendsRemb) {
     }
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, VerifyBandwidthStats) {
-  class RtcpObserver : public test::EndToEndTest, public PacketReceiver {
+  class RtcpObserver : public test::EndToEndTest {
    public:
     RtcpObserver()
         : EndToEndTest(kDefaultTimeoutMs),
@@ -1706,10 +1717,7 @@ TEST_F(EndToEndTest, VerifyBandwidthStats) {
           receiver_call_(nullptr),
           has_seen_pacer_delay_(false) {}
 
-    DeliveryStatus DeliverPacket(MediaType media_type,
-                                 const uint8_t* packet,
-                                 size_t length,
-                                 const PacketTime& packet_time) override {
+    Action OnSendRtp(const uint8_t* packet, size_t length) override {
       Call::Stats sender_stats = sender_call_->GetStats();
       Call::Stats receiver_stats = receiver_call_->GetStats();
       if (!has_seen_pacer_delay_)
@@ -1718,8 +1726,7 @@ TEST_F(EndToEndTest, VerifyBandwidthStats) {
           receiver_stats.recv_bandwidth_bps > 0 && has_seen_pacer_delay_) {
         observation_complete_->Set();
       }
-      return receiver_call_->Receiver()->DeliverPacket(media_type, packet,
-                                                       length, packet_time);
+      return SEND_PACKET;
     }
 
     void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
@@ -1732,18 +1739,13 @@ TEST_F(EndToEndTest, VerifyBandwidthStats) {
                                            "non-zero bandwidth stats.";
     }
 
-    void SetReceivers(PacketReceiver* send_transport_receiver,
-                      PacketReceiver* receive_transport_receiver) override {
-      test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver);
-    }
-
    private:
     Call* sender_call_;
     Call* receiver_call_;
     bool has_seen_pacer_delay_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, VerifyNackStats) {
@@ -1844,7 +1846,7 @@ TEST_F(EndToEndTest, VerifyNackStats) {
   } test;
 
   test::ClearHistograms();
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.UniqueNackRequestsSentInPercent"));
@@ -1857,7 +1859,7 @@ TEST_F(EndToEndTest, VerifyNackStats) {
 }
 
 void EndToEndTest::VerifyHistogramStats(bool use_rtx, bool use_red) {
-  class StatsObserver : public test::EndToEndTest, public PacketReceiver {
+  class StatsObserver : public test::EndToEndTest {
    public:
     StatsObserver(bool use_rtx, bool use_red)
         : EndToEndTest(kLongTimeoutMs),
@@ -1872,20 +1874,13 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx, bool use_red) {
       if (MinMetricRunTimePassed())
         observation_complete_->Set();
 
-      return SEND_PACKET;
-    }
-
-    DeliveryStatus DeliverPacket(MediaType media_type,
-                                 const uint8_t* packet,
-                                 size_t length,
-                                 const PacketTime& packet_time) override {
       // GetStats calls GetSendChannelRtcpStatistics
       // (via VideoSendStream::GetRtt) which updates ReportBlockStats used by
       // WebRTC.Video.SentPacketsLostInPercent.
       // TODO(asapersson): Remove dependency on calling GetStats.
       sender_call_->GetStats();
-      return receiver_call_->Receiver()->DeliverPacket(media_type, packet,
-                                                       length, packet_time);
+
+      return SEND_PACKET;
     }
 
     bool MinMetricRunTimePassed() {
@@ -1927,11 +1922,6 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx, bool use_red) {
       receiver_call_ = receiver_call;
     }
 
-    void SetReceivers(PacketReceiver* send_transport_receiver,
-                      PacketReceiver* receive_transport_receiver) override {
-      test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver);
-    }
-
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait())
           << "Timed out waiting for packet to be NACKed.";
@@ -1945,7 +1935,7 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx, bool use_red) {
   } test(use_rtx, use_red);
 
   test::ClearHistograms();
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 
   // Verify that stats have been updated once.
   EXPECT_EQ(1, test::NumHistogramSamples(
@@ -2129,7 +2119,7 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
     int sent_rtcp_dlrr_;
   } test(enable_rrtr);
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
@@ -2227,7 +2217,7 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
     VideoEncoderConfig encoder_config_all_streams_;
   } test(kSendSsrcs, num_ssrcs, send_single_ssrc_first);
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, ReportsSetEncoderRates) {
@@ -2282,11 +2272,12 @@ TEST_F(EndToEndTest, ReportsSetEncoderRates) {
     }
 
    private:
+    rtc::CriticalSection crit_;
     VideoSendStream* send_stream_;
     uint32_t bitrate_kbps_ GUARDED_BY(crit_);
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, GetStats) {
@@ -2294,8 +2285,8 @@ TEST_F(EndToEndTest, GetStats) {
   static const int kExpectedRenderDelayMs = 20;
   class StatsObserver : public test::EndToEndTest, public I420FrameCallback {
    public:
-    explicit StatsObserver(const FakeNetworkPipe::Config& config)
-        : EndToEndTest(kLongTimeoutMs, config),
+    StatsObserver()
+        : EndToEndTest(kLongTimeoutMs),
           send_stream_(nullptr),
           expected_send_ssrcs_(),
           check_stats_event_(EventWrapper::Create()) {}
@@ -2542,13 +2533,11 @@ TEST_F(EndToEndTest, GetStats) {
     std::string expected_cname_;
 
     rtc::scoped_ptr<EventWrapper> check_stats_event_;
-  };
+  } test;
 
   FakeNetworkPipe::Config network_config;
   network_config.loss_percent = 5;
-
-  StatsObserver test(network_config);
-  RunBaseTest(&test);
+  RunBaseTest(&test, network_config);
 }
 
 TEST_F(EndToEndTest, ReceiverReferenceTimeReportEnabled) {
@@ -2596,7 +2585,7 @@ TEST_F(EndToEndTest, TestReceivedRtpPacketStats) {
     uint32_t sent_rtp_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, SendsSetSsrc) { TestSendsSetSsrcs(1, false); }
@@ -2676,7 +2665,7 @@ TEST_F(EndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
     std::map<uint32_t, bool> registered_rtx_ssrc_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
@@ -2771,9 +2760,17 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
   } observer(use_rtx);
 
   CreateCalls(Call::Config(), Call::Config());
-  observer.SetReceivers(sender_call_->Receiver(), nullptr);
 
-  CreateSendConfig(kNumSsrcs, observer.SendTransport());
+  test::PacketTransport send_transport(sender_call_.get(), &observer,
+                                       test::PacketTransport::kSender,
+                                       FakeNetworkPipe::Config());
+  test::PacketTransport receive_transport(nullptr, &observer,
+                                          test::PacketTransport::kReceiver,
+                                          FakeNetworkPipe::Config());
+  send_transport.SetReceiver(receiver_call_->Receiver());
+  receive_transport.SetReceiver(sender_call_->Receiver());
+
+  CreateSendConfig(kNumSsrcs, &send_transport);
 
   if (use_rtx) {
     for (size_t i = 0; i < kNumSsrcs; ++i) {
@@ -2802,7 +2799,7 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
         encoder_config_.streams[i].max_bitrate_bps;
   }
 
-  CreateMatchingReceiveConfigs(observer.ReceiveTransport());
+  CreateMatchingReceiveConfigs(&receive_transport);
 
   CreateStreams();
   CreateFrameGeneratorCapturer();
@@ -2847,7 +2844,8 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
         << "Timed out waiting for all SSRCs to send packets.";
   }
 
-  observer.StopSending();
+  send_transport.StopSending();
+  receive_transport.StopSending();
 
   Stop();
   DestroyStreams();
@@ -3033,7 +3031,7 @@ TEST_F(EndToEndTest, RespectsNetworkState) {
     int down_frames_ GUARDED_BY(test_crit_);
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, CallReportsRttForSender) {
@@ -3044,9 +3042,9 @@ TEST_F(EndToEndTest, CallReportsRttForSender) {
 
   FakeNetworkPipe::Config config;
   config.queue_delay_ms = kSendDelayMs;
-  test::DirectTransport sender_transport(config);
+  test::DirectTransport sender_transport(config, sender_call_.get());
   config.queue_delay_ms = kReceiveDelayMs;
-  test::DirectTransport receiver_transport(config);
+  test::DirectTransport receiver_transport(config, receiver_call_.get());
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
@@ -3108,7 +3106,7 @@ TEST_F(EndToEndTest, NewReceiveStreamsRespectNetworkDown) {
   CreateCalls(Call::Config(), Call::Config());
   receiver_call_->SignalNetworkState(kNetworkDown);
 
-  test::DirectTransport sender_transport;
+  test::DirectTransport sender_transport(sender_call_.get());
   sender_transport.SetReceiver(receiver_call_->Receiver());
   CreateSendConfig(1, &sender_transport);
   UnusedTransport transport;
diff --git a/webrtc/video/rampup_tests.cc b/webrtc/video/rampup_tests.cc
index 8c6b026b43..d0ce8a11dd 100644
--- a/webrtc/video/rampup_tests.cc
+++ b/webrtc/video/rampup_tests.cc
@@ -89,6 +89,13 @@ void RampUpTester::OnStreamsCreated(
   send_stream_ = send_stream;
 }
 
+void RampUpTester::OnTransportsCreated(
+    test::PacketTransport* send_transport,
+    test::PacketTransport* receive_transport) {
+  send_transport_ = send_transport;
+  send_transport_->SetConfig(forward_transport_config_);
+}
+
 size_t RampUpTester::GetNumStreams() const {
   return num_streams_;
 }
@@ -286,7 +293,6 @@ RampUpDownUpTester::RampUpDownUpTester(size_t num_streams,
       sent_bytes_(0) {
   forward_transport_config_.link_capacity_kbps =
       kHighBandwidthLimitBps / 1000;
-  send_transport_.SetConfig(forward_transport_config_);
 }
 
 RampUpDownUpTester::~RampUpDownUpTester() {}
@@ -334,7 +340,7 @@ void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) {
         // channel limit, and move to the next test state.
         forward_transport_config_.link_capacity_kbps =
             kLowBandwidthLimitBps / 1000;
-        send_transport_.SetConfig(forward_transport_config_);
+        send_transport_->SetConfig(forward_transport_config_);
         test_state_ = kLowRate;
         webrtc::test::PrintResult("ramp_up_down_up",
                                   GetModifierString(),
@@ -354,7 +360,7 @@ void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) {
         // high value, and move to the next test state.
         forward_transport_config_.link_capacity_kbps =
             kHighBandwidthLimitBps / 1000;
-        send_transport_.SetConfig(forward_transport_config_);
+        send_transport_->SetConfig(forward_transport_config_);
         test_state_ = kSecondRampup;
         webrtc::test::PrintResult("ramp_up_down_up",
                                   GetModifierString(),
@@ -395,109 +401,109 @@ class RampUpTest : public test::CallTest {
 
 TEST_F(RampUpTest, SingleStream) {
   RampUpTester test(1, 0, RtpExtension::kTOffset, false, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, Simulcast) {
   RampUpTester test(3, 0, RtpExtension::kTOffset, false, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, SimulcastWithRtx) {
   RampUpTester test(3, 0, RtpExtension::kTOffset, true, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, SimulcastByRedWithRtx) {
   RampUpTester test(3, 0, RtpExtension::kTOffset, true, true);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, SingleStreamWithHighStartBitrate) {
   RampUpTester test(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kTOffset,
                     false, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, UpDownUpOneStream) {
   RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, false, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, UpDownUpThreeStreams) {
   RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, false, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, UpDownUpOneStreamRtx) {
   RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, true, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, UpDownUpThreeStreamsRtx) {
   RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, true, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, UpDownUpOneStreamByRedRtx) {
   RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, true, true);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, UpDownUpThreeStreamsByRedRtx) {
   RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, true, true);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, AbsSendTimeSingleStream) {
   RampUpTester test(1, 0, RtpExtension::kAbsSendTime, false, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, AbsSendTimeSimulcast) {
   RampUpTester test(3, 0, RtpExtension::kAbsSendTime, false, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, AbsSendTimeSimulcastWithRtx) {
   RampUpTester test(3, 0, RtpExtension::kAbsSendTime, true, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, AbsSendTimeSimulcastByRedWithRtx) {
   RampUpTester test(3, 0, RtpExtension::kAbsSendTime, true, true);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, AbsSendTimeSingleStreamWithHighStartBitrate) {
   RampUpTester test(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kAbsSendTime,
                     false, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSingleStream) {
   RampUpTester test(1, 0, RtpExtension::kTransportSequenceNumber, false, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSimulcast) {
   RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, false, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSimulcastWithRtx) {
   RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, true, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSimulcastByRedWithRtx) {
   RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, true, true);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSingleStreamWithHighStartBitrate) {
   RampUpTester test(1, 0.9 * kSingleStreamTargetBps,
                     RtpExtension::kTransportSequenceNumber, false, false);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 }  // namespace webrtc
diff --git a/webrtc/video/rampup_tests.h b/webrtc/video/rampup_tests.h
index 927d912577..9a046568de 100644
--- a/webrtc/video/rampup_tests.h
+++ b/webrtc/video/rampup_tests.h
@@ -63,10 +63,12 @@ class RampUpTester : public test::EndToEndTest {
 
   rtc::Event event_;
   Clock* const clock_;
+  FakeNetworkPipe::Config forward_transport_config_;
   const size_t num_streams_;
   const bool rtx_;
   const bool red_;
   VideoSendStream* send_stream_;
+  test::PacketTransport* send_transport_;
 
  private:
   typedef std::map<uint32_t, uint32_t> SsrcMap;
@@ -75,6 +77,8 @@ class RampUpTester : public test::EndToEndTest {
   void OnStreamsCreated(
       VideoSendStream* send_stream,
       const std::vector<VideoReceiveStream*>& receive_streams) override;
+  void OnTransportsCreated(test::PacketTransport* send_transport,
+                           test::PacketTransport* receive_transport) override;
   size_t GetNumStreams() const;
   void ModifyConfigs(VideoSendStream::Config* send_config,
                      std::vector<VideoReceiveStream::Config>* receive_configs,
@@ -122,7 +126,6 @@ class RampUpDownUpTester : public RampUpTester {
   std::string GetModifierString() const;
   void EvolveTestState(int bitrate_bps, bool suspended);
 
-  FakeNetworkPipe::Config forward_transport_config_;
   TestStates test_state_;
   int64_t state_start_ms_;
   int64_t interval_start_ms_;
diff --git a/webrtc/video/video_quality_test.cc b/webrtc/video/video_quality_test.cc
index 1513b818ce..a475c9ff9c 100644
--- a/webrtc/video/video_quality_test.cc
+++ b/webrtc/video/video_quality_test.cc
@@ -247,7 +247,7 @@ class VideoAnalyzer : public PacketReceiver,
   }
 
   VideoCaptureInput* input_;
-  Transport* transport_;
+  Transport* const transport_;
   PacketReceiver* receiver_;
   VideoSendStream* send_stream_;
 
@@ -756,20 +756,21 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
         << params.analyzer.graph_data_output_filename << "!";
   }
 
+  Call::Config call_config;
+  call_config.bitrate_config = params.common.call_bitrate_config;
+  CreateCalls(call_config, call_config);
+
   test::LayerFilteringTransport send_transport(
-      params.pipe, kPayloadTypeVP8, kPayloadTypeVP9,
+      params.pipe, sender_call_.get(), kPayloadTypeVP8, kPayloadTypeVP9,
       static_cast<uint8_t>(params.common.tl_discard_threshold), 0);
-  test::DirectTransport recv_transport(params.pipe);
+  test::DirectTransport recv_transport(params.pipe, receiver_call_.get());
+
   VideoAnalyzer analyzer(
       &send_transport, params.analyzer.test_label,
       params.analyzer.avg_psnr_threshold, params.analyzer.avg_ssim_threshold,
       params.analyzer.test_durations_secs * params.common.fps,
       graph_data_output_file);
 
-  Call::Config call_config;
-  call_config.bitrate_config = params.common.call_bitrate_config;
-  CreateCalls(call_config, call_config);
-
   analyzer.SetReceiver(receiver_call_->Receiver());
   send_transport.SetReceiver(&analyzer);
   recv_transport.SetReceiver(sender_call_->Receiver());
@@ -827,7 +828,7 @@ void VideoQualityTest::RunWithVideoRenderer(const Params& params) {
   rtc::scoped_ptr<Call> call(Call::Create(call_config));
 
   test::LayerFilteringTransport transport(
-      params.pipe, kPayloadTypeVP8, kPayloadTypeVP9,
+      params.pipe, call.get(), kPayloadTypeVP8, kPayloadTypeVP9,
       static_cast<uint8_t>(params.common.tl_discard_threshold), 0);
   // TODO(ivica): Use two calls to be able to merge with RunWithAnalyzer or at
   // least share as much code as possible. That way this test would also match
diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc
index 40aaf32ea8..92e3b73179 100644
--- a/webrtc/video/video_send_stream_tests.cc
+++ b/webrtc/video/video_send_stream_tests.cc
@@ -120,7 +120,7 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
     }
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
@@ -159,7 +159,7 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
     }
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
@@ -204,7 +204,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
     test::DelayedEncoder encoder_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
@@ -247,7 +247,7 @@ TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
     test::FakeEncoder encoder_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 class FakeReceiveStatistics : public NullReceiveStatistics {
@@ -311,11 +311,9 @@ TEST_F(VideoSendStreamTest, SupportsFec) {
    public:
     FecObserver()
         : SendTest(kDefaultTimeoutMs),
-          transport_adapter_(SendTransport()),
           send_count_(0),
           received_media_(false),
           received_fec_(false) {
-      transport_adapter_.Enable();
     }
 
    private:
@@ -330,7 +328,7 @@ TEST_F(VideoSendStreamTest, SupportsFec) {
             kSendSsrcs[0], header.sequenceNumber, send_count_ / 2, 127);
         RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(),
                                &lossy_receive_stats, nullptr,
-                               &transport_adapter_);
+                               transport_adapter_.get());
 
         rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
         rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
@@ -367,6 +365,9 @@ TEST_F(VideoSendStreamTest, SupportsFec) {
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
+      transport_adapter_.reset(
+          new internal::TransportAdapter(send_config->send_transport));
+      transport_adapter_->Enable();
       send_config->rtp.fec.red_payload_type = kRedPayloadType;
       send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
     }
@@ -375,13 +376,13 @@ TEST_F(VideoSendStreamTest, SupportsFec) {
       EXPECT_TRUE(Wait()) << "Timed out waiting for FEC and media packets.";
     }
 
-    internal::TransportAdapter transport_adapter_;
+    rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
     int send_count_;
     bool received_media_;
     bool received_fec_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 void VideoSendStreamTest::TestNackRetransmission(
@@ -392,12 +393,10 @@ void VideoSendStreamTest::TestNackRetransmission(
     explicit NackObserver(uint32_t retransmit_ssrc,
                           uint8_t retransmit_payload_type)
         : SendTest(kDefaultTimeoutMs),
-          transport_adapter_(SendTransport()),
           send_count_(0),
           retransmit_ssrc_(retransmit_ssrc),
           retransmit_payload_type_(retransmit_payload_type),
           nacked_sequence_number_(-1) {
-      transport_adapter_.Enable();
     }
 
    private:
@@ -411,7 +410,7 @@ void VideoSendStreamTest::TestNackRetransmission(
         nacked_sequence_number_ = nack_sequence_number;
         NullReceiveStatistics null_stats;
         RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(), &null_stats,
-                               nullptr, &transport_adapter_);
+                               nullptr, transport_adapter_.get());
 
         rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
         rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
@@ -445,6 +444,9 @@ void VideoSendStreamTest::TestNackRetransmission(
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
+      transport_adapter_.reset(
+          new internal::TransportAdapter(send_config->send_transport));
+      transport_adapter_->Enable();
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       send_config->rtp.rtx.payload_type = retransmit_payload_type_;
       if (retransmit_ssrc_ != kSendSsrcs[0])
@@ -456,14 +458,14 @@ void VideoSendStreamTest::TestNackRetransmission(
           << "Timed out while waiting for NACK retransmission.";
     }
 
-    internal::TransportAdapter transport_adapter_;
+    rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
     int send_count_;
     uint32_t retransmit_ssrc_;
     uint8_t retransmit_payload_type_;
     int nacked_sequence_number_;
   } test(retransmit_ssrc, retransmit_payload_type);
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, RetransmitsNack) {
@@ -496,7 +498,6 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
                            bool test_generic_packetization,
                            bool use_fec)
         : SendTest(kLongTimeoutMs),
-          transport_adapter_(SendTransport()),
           encoder_(stop),
           max_packet_size_(max_packet_size),
           stop_size_(stop_size),
@@ -511,7 +512,6 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
       // Fragmentation required, this test doesn't make sense without it.
       encoder_.SetFrameSize(start_size);
       RTC_DCHECK_GT(stop_size, max_packet_size);
-      transport_adapter_.Enable();
     }
 
    private:
@@ -598,7 +598,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
             kSendSsrcs[0], header.sequenceNumber, packet_count_ / 2, 127);
         RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(),
                                &lossy_receive_stats, nullptr,
-                               &transport_adapter_);
+                               transport_adapter_.get());
 
         rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
         rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
@@ -629,6 +629,9 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
+      transport_adapter_.reset(
+          new internal::TransportAdapter(send_config->send_transport));
+      transport_adapter_->Enable();
       if (use_fec_) {
         send_config->rtp.fec.red_payload_type = kRedPayloadType;
         send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
@@ -651,7 +654,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
           << "Timed out while observing incoming RTP packets.";
     }
 
-    internal::TransportAdapter transport_adapter_;
+    rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
     test::ConfigurableFrameSizeEncoder encoder_;
 
     const size_t max_packet_size_;
@@ -673,7 +676,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
   FrameFragmentationTest test(
       kMaxPacketSize, start, stop, format == kGeneric, with_fec);
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 // TODO(sprang): Is there any way of speeding up these tests?
@@ -709,7 +712,6 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
    public:
     RembObserver()
         : SendTest(kDefaultTimeoutMs),
-          transport_adapter_(&transport_),
           clock_(Clock::GetRealTimeClock()),
           test_state_(kBeforeSuspend),
           rtp_count_(0),
@@ -717,18 +719,9 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
           suspended_frame_count_(0),
           low_remb_bps_(0),
           high_remb_bps_(0) {
-      transport_adapter_.Enable();
     }
 
    private:
-    Action OnSendRtcp(const uint8_t* packet, size_t length) override {
-      // Receive statistics reporting having lost 0% of the packets.
-      // This is needed for the send-side bitrate controller to work properly.
-      rtc::CritScope lock(&crit_);
-      SendRtcpFeedback(0);  // REMB is only sent if value is > 0.
-      return SEND_PACKET;
-    }
-
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       rtc::CritScope lock(&crit_);
       ++rtp_count_;
@@ -746,18 +739,21 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
           // counter.
           suspended_frame_count_ = 0;
         }
+        SendRtcpFeedback(0);  // REMB is only sent if value is > 0.
       } else if (test_state_ == kWaitingForPacket) {
         if (header.paddingLength == 0) {
           // Non-padding packet observed. Test is almost complete. Will just
           // have to wait for the stats to change.
           test_state_ = kWaitingForStats;
         }
+        SendRtcpFeedback(0);  // REMB is only sent if value is > 0.
       } else if (test_state_ == kWaitingForStats) {
         VideoSendStream::Stats stats = stream_->GetStats();
         if (stats.suspended == false) {
           // Stats flipped to false. Test is complete.
           observation_complete_->Set();
         }
+        SendRtcpFeedback(0);  // REMB is only sent if value is > 0.
       }
 
       return SEND_PACKET;
@@ -785,11 +781,6 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
       high_remb_bps_ = value;
     }
 
-    void SetReceivers(PacketReceiver* send_transport_receiver,
-                      PacketReceiver* receive_transport_receiver) override {
-      transport_.SetReceiver(send_transport_receiver);
-    }
-
     void OnStreamsCreated(
         VideoSendStream* send_stream,
         const std::vector<VideoReceiveStream*>& receive_streams) override {
@@ -799,6 +790,9 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
+      transport_adapter_.reset(
+          new internal::TransportAdapter(send_config->send_transport));
+      transport_adapter_->Enable();
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       send_config->pre_encode_callback = this;
       send_config->suspend_below_min_bitrate = true;
@@ -813,7 +807,6 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait())
           << "Timed out during suspend-below-min-bitrate test.";
-      transport_.StopSending();
     }
 
     enum TestState {
@@ -828,7 +821,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
       FakeReceiveStatistics receive_stats(
           kSendSsrcs[0], last_sequence_number_, rtp_count_, 0);
       RTCPSender rtcp_sender(false, clock_, &receive_stats, nullptr,
-                             &transport_adapter_);
+                             transport_adapter_.get());
 
       rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
       rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
@@ -840,8 +833,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
       EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr));
     }
 
-    internal::TransportAdapter transport_adapter_;
-    test::DirectTransport transport_;
+    rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
     Clock* const clock_;
     VideoSendStream* stream_;
 
@@ -854,7 +846,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
     int high_remb_bps_ GUARDED_BY(crit_);
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
@@ -863,10 +855,8 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
     NoPaddingWhenVideoIsMuted()
         : SendTest(kDefaultTimeoutMs),
           clock_(Clock::GetRealTimeClock()),
-          transport_adapter_(ReceiveTransport()),
           last_packet_time_ms_(-1),
           capturer_(nullptr) {
-      transport_adapter_.Enable();
     }
 
    private:
@@ -887,7 +877,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
       // Receive statistics reporting having lost 50% of the packets.
       FakeReceiveStatistics receive_stats(kSendSsrcs[0], 1, 1, 0);
       RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(), &receive_stats,
-                             nullptr, &transport_adapter_);
+                             nullptr, transport_adapter_.get());
 
       rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
       rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
@@ -898,10 +888,12 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
       return SEND_PACKET;
     }
 
-    void SetReceivers(PacketReceiver* send_transport_receiver,
-                      PacketReceiver* receive_transport_receiver) override {
-      RtpRtcpObserver::SetReceivers(send_transport_receiver,
-                                    send_transport_receiver);
+    void OnTransportsCreated(
+        test::PacketTransport* send_transport,
+        test::PacketTransport* receive_transport) override {
+      transport_adapter_.reset(
+          new internal::TransportAdapter(receive_transport));
+      transport_adapter_->Enable();
     }
 
     size_t GetNumStreams() const override { return 3; }
@@ -918,13 +910,13 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
     }
 
     Clock* const clock_;
-    internal::TransportAdapter transport_adapter_;
+    rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
     rtc::CriticalSection crit_;
     int64_t last_packet_time_ms_ GUARDED_BY(crit_);
     test::FrameGeneratorCapturer* capturer_ GUARDED_BY(crit_);
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 // This test first observes "high" bitrate use at which point it sends a REMB to
@@ -939,39 +931,21 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
   static const int kHighBitrateBps = 150000;
   static const int kRembBitrateBps = 80000;
   static const int kRembRespectedBitrateBps = 100000;
-  class BitrateObserver : public test::SendTest, public PacketReceiver {
+  class BitrateObserver : public test::SendTest {
    public:
     BitrateObserver()
         : SendTest(kDefaultTimeoutMs),
-          feedback_transport_(ReceiveTransport()),
           bitrate_capped_(false) {
-      RtpRtcp::Configuration config;
-      feedback_transport_.Enable();
-      config.outgoing_transport = &feedback_transport_;
-      rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
-      rtp_rtcp_->SetREMBStatus(true);
-      rtp_rtcp_->SetRTCPStatus(RtcpMode::kReducedSize);
-    }
-
-    void OnStreamsCreated(
-        VideoSendStream* send_stream,
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
-      stream_ = send_stream;
     }
 
    private:
-    DeliveryStatus DeliverPacket(MediaType media_type,
-                                 const uint8_t* packet,
-                                 size_t length,
-                                 const PacketTime& packet_time) override {
-      EXPECT_TRUE(media_type == MediaType::ANY ||
-                  media_type == MediaType::VIDEO);
+    virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
       if (RtpHeaderParser::IsRtcp(packet, length))
-        return DELIVERY_OK;
+        return DROP_PACKET;
 
       RTPHeader header;
       if (!parser_->Parse(packet, length, &header))
-        return DELIVERY_PACKET_ERROR;
+        return DROP_PACKET;
       RTC_DCHECK(stream_ != nullptr);
       VideoSendStream::Stats stats = stream_->GetStats();
       if (!stats.substreams.empty()) {
@@ -994,17 +968,27 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
           observation_complete_->Set();
         }
       }
-      return DELIVERY_OK;
+      // Packets don't have to be delivered since the test is the receiver.
+      return DROP_PACKET;
     }
 
-    void SetReceivers(PacketReceiver* send_transport_receiver,
-                      PacketReceiver* receive_transport_receiver) override {
-      RtpRtcpObserver::SetReceivers(this, send_transport_receiver);
+    void OnStreamsCreated(
+        VideoSendStream* send_stream,
+        const std::vector<VideoReceiveStream*>& receive_streams) override {
+      stream_ = send_stream;
+      RtpRtcp::Configuration config;
+      config.outgoing_transport = feedback_transport_.get();
+      rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
+      rtp_rtcp_->SetREMBStatus(true);
+      rtp_rtcp_->SetRTCPStatus(RtcpMode::kReducedSize);
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
+      feedback_transport_.reset(
+          new internal::TransportAdapter(send_config->send_transport));
+      feedback_transport_->Enable();
       encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps;
     }
 
@@ -1014,12 +998,12 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
     }
 
     rtc::scoped_ptr<RtpRtcp> rtp_rtcp_;
-    internal::TransportAdapter feedback_transport_;
+    rtc::scoped_ptr<internal::TransportAdapter> feedback_transport_;
     VideoSendStream* stream_;
     bool bitrate_capped_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
@@ -1329,7 +1313,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
     VideoEncoderConfig encoder_config_;
   } test_encoder;
 
-  RunBaseTest(&test_encoder);
+  RunBaseTest(&test_encoder, FakeNetworkPipe::Config());
 
   EXPECT_TRUE(test_encoder.IsReleased());
   EXPECT_EQ(1u, test_encoder.num_releases());
@@ -1387,7 +1371,7 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) {
     VideoEncoderConfig encoder_config_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 static const size_t kVideoCodecConfigObserverNumberOfTemporalLayers = 4;
@@ -1515,17 +1499,17 @@ void VideoCodecConfigObserver<VideoCodecVP9>::VerifyCodecSpecifics(
 
 TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
   VideoCodecConfigObserver<VideoCodecVP8> test(kVideoCodecVP8, "VP8");
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp9Config) {
   VideoCodecConfigObserver<VideoCodecVP9> test(kVideoCodecVP9, "VP9");
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, EncoderSetupPropagatesH264Config) {
   VideoCodecConfigObserver<VideoCodecH264> test(kVideoCodecH264, "H264");
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
@@ -1575,7 +1559,7 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
     size_t media_bytes_sent_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
@@ -1615,7 +1599,7 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
     }
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
@@ -1721,7 +1705,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
     webrtc::VideoEncoderConfig encoder_config_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, ReportsSentResolution) {
@@ -1800,7 +1784,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
     VideoSendStream* send_stream_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 class VP9HeaderObeserver : public test::SendTest {
@@ -1880,7 +1864,7 @@ TEST_F(VideoSendStreamTest, VP9NoFlexMode) {
     }
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, DISABLED_VP9FlexMode) {
@@ -1899,7 +1883,7 @@ TEST_F(VideoSendStreamTest, DISABLED_VP9FlexMode) {
 
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 }  // namespace webrtc