Call OnSentPacket for all packets sent in the test framework.

webrtc/video/end_to_end_tests.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include <algorithm>
@@ skipping 63 matching lines @@
       return false;
     }
   };
 
   void DecodesRetransmittedFrame(bool use_rtx, bool use_red);
   void ReceivesPliAndRecovers(int rtp_history_ms);
   void RespectsRtcpMode(RtcpMode rtcp_mode);
   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);
 };
 
 TEST_F(EndToEndTest, ReceiverCanBeStartedTwice) {
   CreateCalls(Call::Config(), Call::Config());
 
   test::NullTransport transport;
   CreateSendConfig(1, &transport);
   CreateMatchingReceiveConfigs(&transport);
 
@@ skipping 54 matching lines @@
     void FrameCallback(VideoFrame* frame) override {
       SleepMs(kDelayRenderCallbackMs);
       event_->Set();
     }
 
     rtc::scoped_ptr<EventWrapper> event_;
   };
 
   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());
 
   CreateSendConfig(1, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
 
   TestFrameCallback pre_render_callback;
   receive_configs_[0].pre_render_callback = &pre_render_callback;
   receive_configs_[0].renderer = &renderer;
 
@@ skipping 29 matching lines @@
     }
     bool IsTextureSupported() const override { return false; }
 
     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 
     rtc::scoped_ptr<EventWrapper> event_;
   } renderer;
 
   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());
 
   CreateSendConfig(1, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
   receive_configs_[0].renderer = &renderer;
 
   CreateStreams();
   Start();
 
@@ skipping 54 matching lines @@
     }
 
     bool IsTextureSupported() const override { return false; }
 
    private:
     rtc::scoped_ptr<webrtc::VideoEncoder> encoder_;
     rtc::scoped_ptr<webrtc::VideoDecoder> decoder_;
     int frame_counter_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, SendsAndReceivesH264) {
   class H264Observer : public test::EndToEndTest, public VideoRenderer {
    public:
     H264Observer()
         : EndToEndTest(2 * kDefaultTimeoutMs),
           fake_encoder_(Clock::GetRealTimeClock()),
           frame_counter_(0) {}
 
@@ skipping 31 matching lines @@
     }
 
     bool IsTextureSupported() const override { return false; }
 
    private:
     test::FakeH264Decoder fake_decoder_;
     test::FakeH264Encoder fake_encoder_;
     int frame_counter_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) {
   class SyncRtcpObserver : public test::EndToEndTest {
    public:
     SyncRtcpObserver() : EndToEndTest(kDefaultTimeoutMs) {}
 
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
       RTCPUtility::RTCPParserV2 parser(packet, length, true);
       EXPECT_TRUE(parser.IsValid());
       uint32_t ssrc = 0;
       ssrc |= static_cast<uint32_t>(packet[4]) << 24;
       ssrc |= static_cast<uint32_t>(packet[5]) << 16;
       ssrc |= static_cast<uint32_t>(packet[6]) << 8;
       ssrc |= static_cast<uint32_t>(packet[7]) << 0;
       EXPECT_EQ(kReceiverLocalSsrc, ssrc);
       observation_complete_->Set();
 
       return SEND_PACKET;
     }
 
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait())
           << "Timed out while waiting for a receiver RTCP packet to be sent.";
     }
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
   static const int kNumberOfNacksToObserve = 2;
   static const int kLossBurstSize = 2;
   static const int kPacketsBetweenLossBursts = 9;
   class NackObserver : public test::EndToEndTest {
    public:
     NackObserver()
         : EndToEndTest(kLongTimeoutMs),
           rtp_parser_(RtpHeaderParser::Create()),
           sent_rtp_packets_(0),
           packets_left_to_drop_(0),
           nacks_left_(kNumberOfNacksToObserve) {}
 
    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));
 
       // Never drop retransmitted packets.
       if (dropped_packets_.find(header.sequenceNumber) !=
           dropped_packets_.end()) {
         retransmitted_packets_.insert(header.sequenceNumber);
         if (nacks_left_ <= 0 &&
             retransmitted_packets_.size() == dropped_packets_.size()) {
           observation_complete_->Set();
@@ skipping 15 matching lines @@
       if (packets_left_to_drop_ > 0 && header.paddingLength == 0) {
         --packets_left_to_drop_;
         dropped_packets_.insert(header.sequenceNumber);
         return DROP_PACKET;
       }
 
       return SEND_PACKET;
     }
 
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
+      rtc::CritScope lock(&crit_);
       RTCPUtility::RTCPParserV2 parser(packet, length, true);
       EXPECT_TRUE(parser.IsValid());
 
       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
       while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
         if (packet_type == RTCPUtility::RTCPPacketTypes::kRtpfbNack) {
           --nacks_left_;
           break;
         }
         packet_type = parser.Iterate();
       }
       return SEND_PACKET;
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
     }
 
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait())
           << "Timed out waiting for packets to be NACKed, retransmitted and "
              "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) {
   class FecRenderObserver : public test::EndToEndTest, public VideoRenderer {
    public:
     FecRenderObserver()
         : 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));
 
       int encapsulated_payload_type = -1;
       if (header.payloadType == kRedPayloadType) {
         encapsulated_payload_type =
             static_cast<int>(packet[header.headerLength]);
         if (encapsulated_payload_type != kFakeSendPayloadType)
           EXPECT_EQ(kUlpfecPayloadType, encapsulated_payload_type);
       } else {
@@ skipping 63 matching lines @@
       (*receive_configs)[0].rtp.fec.red_payload_type = kRedPayloadType;
       (*receive_configs)[0].rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
       (*receive_configs)[0].renderer = this;
     }
 
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait())
           << "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),
           last_sequence_number_(0) {}
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
@@ skipping 87 matching lines @@
     enum {
       kFirstPacket,
       kDropEveryOtherPacketUntilFec,
       kDropAllMediaPacketsUntilFec,
       kVerifyFecPacketNotInNackList,
     } state_;
 
     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
 // retransmitted and renders. Retransmission SSRCs are also checked.
 void EndToEndTest::DecodesRetransmittedFrame(bool use_rtx, bool use_red) {
   // Must be set high enough to allow the bitrate probing to finish.
   static const int kMinProbePackets = 30;
   static const int kDroppedFrameNumber = kMinProbePackets + 1;
   class RetransmissionObserver : public test::EndToEndTest,
                                  public I420FrameCallback {
    public:
     explicit RetransmissionObserver(bool use_rtx, bool use_red)
         : EndToEndTest(kDefaultTimeoutMs),
           payload_type_(GetPayloadType(false, use_red)),
           retransmission_ssrc_(use_rtx ? kSendRtxSsrcs[0] : kSendSsrcs[0]),
           retransmission_payload_type_(GetPayloadType(use_rtx, use_red)),
           marker_bits_observed_(0),
           num_packets_observed_(0),
           retransmitted_timestamp_(0),
           frame_retransmitted_(false) {}
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
+      rtc::CritScope lock(&crit_);
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
       // We accept some padding or RTX packets in the beginning to enable
       // bitrate probing.
       if (num_packets_observed_++ < kMinProbePackets &&
           header.payloadType != payload_type_) {
         EXPECT_TRUE(retransmission_payload_type_ == header.payloadType ||
                     length == header.headerLength + header.paddingLength);
         return SEND_PACKET;
@@ skipping 53 matching lines @@
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait())
           << "Timed out while waiting for retransmission to render.";
     }
 
     int GetPayloadType(bool use_rtx, bool use_red) {
       return use_rtx ? kSendRtxPayloadType
                      : (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) {
   DecodesRetransmittedFrame(false, false);
 }
 
 TEST_F(EndToEndTest, DecodesRetransmittedFrameOverRtx) {
   DecodesRetransmittedFrame(true, false);
 }
 
@@ skipping 58 matching lines @@
     rtc::scoped_ptr<EventWrapper> event_;
     int expected_luma_byte_;
     int next_luma_byte_;
   };
 
   TestFrameCallback pre_encode_callback(-1, 255);  // Changes luma to 255.
   TestFrameCallback pre_render_callback(255, 0);  // Changes luma from 255 to 0.
 
   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());
 
   CreateSendConfig(1, &sender_transport);
   rtc::scoped_ptr<VideoEncoder> encoder(
       VideoEncoder::Create(VideoEncoder::kVp8));
   send_config_.encoder_settings.encoder = encoder.get();
   send_config_.encoder_settings.payload_name = "VP8";
   ASSERT_EQ(1u, encoder_config_.streams.size()) << "Test setup error.";
   encoder_config_.streams[0].width = kWidth;
@@ skipping 36 matching lines @@
     explicit PliObserver(int rtp_history_ms)
         : EndToEndTest(kLongTimeoutMs),
           rtp_history_ms_(rtp_history_ms),
           nack_enabled_(rtp_history_ms > 0),
           highest_dropped_timestamp_(0),
           frames_to_drop_(0),
           received_pli_(false) {}
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
+      rtc::CritScope lock(&crit_);
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
       // Drop all retransmitted packets to force a PLI.
       if (header.timestamp <= highest_dropped_timestamp_)
         return DROP_PACKET;
 
       if (frames_to_drop_ > 0) {
         highest_dropped_timestamp_ = header.timestamp;
         --frames_to_drop_;
         return DROP_PACKET;
       }
 
       return SEND_PACKET;
     }
 
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
+      rtc::CritScope lock(&crit_);
       RTCPUtility::RTCPParserV2 parser(packet, length, true);
       EXPECT_TRUE(parser.IsValid());
 
       for (RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
            packet_type != RTCPUtility::RTCPPacketTypes::kInvalid;
            packet_type = parser.Iterate()) {
         if (!nack_enabled_)
           EXPECT_NE(packet_type, RTCPUtility::RTCPPacketTypes::kRtpfbNack);
 
         if (packet_type == RTCPUtility::RTCPPacketTypes::kPsfbPli) {
@@ skipping 24 matching lines @@
       (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms_;
       (*receive_configs)[0].renderer = this;
     }
 
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait()) << "Timed out waiting for PLI to be "
                                            "received and a frame to be "
                                            "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) {
   ReceivesPliAndRecovers(1000);
 }
 
 // TODO(pbos): Enable this when 2250 is resolved.
 TEST_F(EndToEndTest, DISABLED_ReceivesPliAndRecoversWithoutNack) {
   ReceivesPliAndRecovers(0);
 }
@@ skipping 24 matching lines @@
         return delivery_status;
       }
     }
 
     PacketReceiver* receiver_;
     rtc::scoped_ptr<EventWrapper> delivered_packet_;
   };
 
   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());
 
   CreateSendConfig(1, &send_transport);
   CreateMatchingReceiveConfigs(&receive_transport);
 
   CreateStreams();
   CreateFrameGeneratorCapturer();
   Start();
@@ skipping 83 matching lines @@
           << (rtcp_mode_ == RtcpMode::kCompound
                   ? "Timed out before observing enough compound packets."
                   : "Timed out before receiving a non-compound RTCP packet.");
     }
 
     RtcpMode rtcp_mode_;
     int sent_rtp_;
     int sent_rtcp_;
   } test(rtcp_mode);
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, UsesRtcpCompoundMode) {
   RespectsRtcpMode(RtcpMode::kCompound);
 }
 
 TEST_F(EndToEndTest, UsesRtcpReducedSizeMode) {
   RespectsRtcpMode(RtcpMode::kReducedSize);
 }
 
@@ skipping 11 matching lines @@
   MultiStreamTest() {
     // TODO(sprang): Cleanup when msvc supports explicit initializers for array.
     codec_settings[0] = {1, 640, 480};
     codec_settings[1] = {2, 320, 240};
     codec_settings[2] = {3, 240, 160};
   }
 
   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());
 
     rtc::scoped_ptr<VideoEncoder> encoders[kNumStreams];
     for (size_t i = 0; i < kNumStreams; ++i)
       encoders[i].reset(VideoEncoder::Create(VideoEncoder::kVp8));
 
     VideoSendStream* send_streams[kNumStreams];
     VideoReceiveStream* receive_streams[kNumStreams];
 
@@ skipping 63 matching lines @@
   // hasn't been created at the time of this call. Only when packets/frames
   // start flowing should this be dereferenced.
   virtual void UpdateSendConfig(
       size_t stream_index,
       VideoSendStream::Config* send_config,
       VideoEncoderConfig* encoder_config,
       test::FrameGeneratorCapturer** frame_generator) {}
   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);
   }
 };
 
 // Each renderer verifies that it receives the expected resolution, and as soon
 // as every renderer has received a frame, the test finishes.
 TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) {
   class VideoOutputObserver : public VideoRenderer {
    public:
     VideoOutputObserver(const MultiStreamTest::CodecSettings& settings,
                         uint32_t ssrc,
@@ skipping 58 matching lines @@
   } tester;
 
   tester.RunTest();
 }
 
 TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
   static const int kExtensionId = 5;
 
   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),
           padding_observed_(false),
           rtx_padding_observed_(false),
           retransmit_observed_(false),
           started_(false) {
       parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
                                           kExtensionId);
     }
@@ skipping 144 matching lines @@
 
     void UpdateReceiveConfig(
         size_t stream_index,
         VideoReceiveStream::Config* receive_config) override {
       receive_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       receive_config->rtp.extensions.clear();
       receive_config->rtp.extensions.push_back(
           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_;
     }
 
    private:
     uint32_t first_media_ssrc_;
     std::map<uint32_t, uint32_t> rtx_to_media_ssrcs_;
     RtpExtensionHeaderObserver* observer_;
   } tester;
 
   tester.RunTest();
 }
 
 TEST_F(EndToEndTest, ReceivesTransportFeedback) {
   static const int kExtensionId = 5;
 
   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 {
       RTCPUtility::RTCPParserV2 parser(data, length, true);
       EXPECT_TRUE(parser.IsValid());
 
       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
       while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
         if (packet_type == RTCPUtility::RTCPPacketTypes::kTransportFeedback) {
           done_->Set();
@@ skipping 27 matching lines @@
           RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId));
     }
 
     void UpdateReceiveConfig(
         size_t stream_index,
         VideoReceiveStream::Config* receive_config) override {
       receive_config->rtp.extensions.push_back(
           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:
     rtc::Event done_;
   } tester;
   tester.RunTest();
 }
 TEST_F(EndToEndTest, ObserversEncodedFrames) {
   class EncodedFrameTestObserver : public EncodedFrameObserver {
    public:
@@ skipping 27 matching lines @@
     size_t length_;
     FrameType frame_type_;
     rtc::scoped_ptr<EventWrapper> called_;
   };
 
   EncodedFrameTestObserver post_encode_observer;
   EncodedFrameTestObserver pre_decode_observer;
 
   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());
 
   CreateSendConfig(1, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
   send_config_.post_encode_callback = &post_encode_observer;
   receive_configs_[0].pre_decode_callback = &pre_decode_observer;
 
   CreateStreams();
   Start();
@@ skipping 49 matching lines @@
         observation_complete_->Set();
       return SEND_PACKET;
     }
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for a "
                                            "receiver RTCP REMB packet to be "
                                            "sent.";
     }
   } 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),
           sender_call_(nullptr),
           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_)
         has_seen_pacer_delay_ = sender_stats.pacer_delay_ms > 0;
       if (sender_stats.send_bandwidth_bps > 0 &&
           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 {
       sender_call_ = sender_call;
       receiver_call_ = receiver_call;
     }
 
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for "
                                            "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) {
   static const int kPacketNumberToDrop = 200;
   class NackObserver : public test::EndToEndTest {
    public:
     NackObserver()
         : EndToEndTest(kLongTimeoutMs),
           sent_rtp_packets_(0),
           dropped_rtp_packet_(0),
@@ skipping 80 matching lines @@
 
     uint64_t sent_rtp_packets_;
     uint16_t dropped_rtp_packet_;
     bool dropped_rtp_packet_requested_;
     std::vector<VideoReceiveStream*> receive_streams_;
     VideoSendStream* send_stream_;
     int64_t start_runtime_ms_;
   } test;
 
   test::ClearHistograms();
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.UniqueNackRequestsSentInPercent"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.UniqueNackRequestsReceivedInPercent"));
   EXPECT_GT(test::LastHistogramSample(
       "WebRTC.Video.NackPacketsSentPerMinute"), 0);
   EXPECT_GT(test::LastHistogramSample(
       "WebRTC.Video.NackPacketsReceivedPerMinute"), 0);
 }
 
 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),
           use_rtx_(use_rtx),
           use_red_(use_red),
           sender_call_(nullptr),
           receiver_call_(nullptr),
           start_runtime_ms_(-1) {}
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       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() {
       int64_t now = Clock::GetRealTimeClock()->TimeInMilliseconds();
       if (start_runtime_ms_ == -1) {
         start_runtime_ms_ = now;
         return false;
       }
       int64_t elapsed_sec = (now - start_runtime_ms_) / 1000;
       return elapsed_sec > metrics::kMinRunTimeInSeconds * 2;
@@ skipping 21 matching lines @@
         (*receive_configs)[0].rtp.rtx[kFakeSendPayloadType].payload_type =
             kSendRtxPayloadType;
       }
     }
 
     void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
       sender_call_ = sender_call;
       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.";
     }
 
     bool use_rtx_;
     bool use_red_;
     Call* sender_call_;
     Call* receiver_call_;
     int64_t start_runtime_ms_;
   } 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(
       "WebRTC.Video.NackPacketsSentPerMinute"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.NackPacketsReceivedPerMinute"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.FirPacketsSentPerMinute"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.FirPacketsReceivedPerMinute"));
@@ skipping 163 matching lines @@
           << "Timed out while waiting for RTCP SR/RR packets to be sent.";
     }
 
     bool enable_rrtr_;
     int sent_rtcp_sr_;
     int sent_rtcp_rr_;
     int sent_rtcp_rrtr_;
     int sent_rtcp_dlrr_;
   } test(enable_rrtr);
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
                                      bool send_single_ssrc_first) {
   class SendsSetSsrcs : public test::EndToEndTest {
    public:
     SendsSetSsrcs(const uint32_t* ssrcs,
                   size_t num_ssrcs,
                   bool send_single_ssrc_first)
         : EndToEndTest(kDefaultTimeoutMs),
@@ skipping 77 matching lines @@
     const size_t num_ssrcs_;
     const bool send_single_ssrc_first_;
 
     size_t ssrcs_to_observe_;
     bool expect_single_ssrc_;
 
     VideoSendStream* send_stream_;
     VideoEncoderConfig encoder_config_all_streams_;
   } test(kSendSsrcs, num_ssrcs, send_single_ssrc_first);
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, ReportsSetEncoderRates) {
   class EncoderRateStatsTest : public test::EndToEndTest,
                                public test::FakeEncoder {
    public:
     EncoderRateStatsTest()
         : EndToEndTest(kDefaultTimeoutMs),
           FakeEncoder(Clock::GetRealTimeClock()),
           send_stream_(nullptr),
@@ skipping 34 matching lines @@
             return;
           }
         }
         SleepMs(1);
       }
       FAIL()
           << "Timed out waiting for stats reporting the currently set bitrate.";
     }
 
    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) {
   static const int kStartBitrateBps = 3000000;
   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()) {}
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       check_stats_event_->Set();
       return SEND_PACKET;
     }
 
@@ skipping 226 matching lines @@
     std::map<std::string, bool> receive_stats_filled_;
 
     VideoSendStream* send_stream_;
     std::map<std::string, bool> send_stats_filled_;
 
     std::vector<uint32_t> expected_receive_ssrcs_;
     std::set<uint32_t> expected_send_ssrcs_;
     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) {
   TestXrReceiverReferenceTimeReport(true);
 }
 
 TEST_F(EndToEndTest, ReceiverReferenceTimeReportDisabled) {
   TestXrReceiverReferenceTimeReport(false);
 }
 
@@ skipping 27 matching lines @@
 
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait())
           << "Timed out while verifying number of received RTP packets.";
     }
 
     VideoReceiveStream* receive_stream_;
     uint32_t sent_rtp_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, SendsSetSsrc) { TestSendsSetSsrcs(1, false); }
 
 TEST_F(EndToEndTest, SendsSetSimulcastSsrcs) {
   TestSendsSetSsrcs(kNumSsrcs, false);
 }
 
 TEST_F(EndToEndTest, CanSwitchToUseAllSsrcs) {
   TestSendsSetSsrcs(kNumSsrcs, true);
@@ skipping 59 matching lines @@
       EXPECT_EQ(kEventSignaled, Wait())
           << "Timed out while waiting for redundant payloads on all SSRCs.";
     }
 
    private:
     size_t ssrcs_to_observe_;
     std::map<uint32_t, bool> observed_redundant_retransmission_;
     std::map<uint32_t, bool> registered_rtx_ssrc_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
   static const uint32_t kMaxSequenceNumberGap = 100;
   static const uint64_t kMaxTimestampGap = kDefaultTimeoutMs * 90;
   class RtpSequenceObserver : public test::RtpRtcpObserver {
    public:
     explicit RtpSequenceObserver(bool use_rtx)
         : test::RtpRtcpObserver(kDefaultTimeoutMs),
           ssrcs_to_observe_(kNumSsrcs) {
@@ skipping 74 matching lines @@
     std::map<uint32_t, uint16_t> last_observed_sequence_number_;
     std::map<uint32_t, uint32_t> last_observed_timestamp_;
     std::map<uint32_t, bool> configured_ssrcs_;
 
     rtc::CriticalSection crit_;
     size_t ssrcs_to_observe_ GUARDED_BY(crit_);
     std::map<uint32_t, bool> ssrc_observed_ GUARDED_BY(crit_);
   } 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) {
       send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
     }
     send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
   }
 
   // Lower bitrates so that all streams send initially.
   for (size_t i = 0; i < encoder_config_.streams.size(); ++i) {
     encoder_config_.streams[i].min_bitrate_bps = 10000;
     encoder_config_.streams[i].target_bitrate_bps = 15000;
     encoder_config_.streams[i].max_bitrate_bps = 20000;
   }
 
   // Use the same total bitrates when sending a single stream to avoid lowering
   // the bitrate estimate and requiring a subsequent rampup.
   VideoEncoderConfig one_stream = encoder_config_;
   one_stream.streams.resize(1);
   for (size_t i = 1; i < encoder_config_.streams.size(); ++i) {
     one_stream.streams.front().min_bitrate_bps +=
         encoder_config_.streams[i].min_bitrate_bps;
     one_stream.streams.front().target_bitrate_bps +=
         encoder_config_.streams[i].target_bitrate_bps;
     one_stream.streams.front().max_bitrate_bps +=
         encoder_config_.streams[i].max_bitrate_bps;
   }
 
-  CreateMatchingReceiveConfigs(observer.ReceiveTransport());
+  CreateMatchingReceiveConfigs(&receive_transport);
 
   CreateStreams();
   CreateFrameGeneratorCapturer();
 
   Start();
   EXPECT_EQ(kEventSignaled, observer.Wait())
       << "Timed out waiting for all SSRCs to send packets.";
 
   // Test stream resetting more than once to make sure that the state doesn't
   // get set once (this could be due to using std::map::insert for instance).
@@ skipping 24 matching lines @@
     EXPECT_EQ(kEventSignaled, observer.Wait())
         << "Timed out waiting for single RTP packet.";
 
     // Reconfigure back to use all streams.
     send_stream_->ReconfigureVideoEncoder(encoder_config_);
     observer.ResetExpectedSsrcs(kNumSsrcs);
     EXPECT_EQ(kEventSignaled, observer.Wait())
         << "Timed out waiting for all SSRCs to send packets.";
   }
 
-  observer.StopSending();
+  send_transport.StopSending();
+  receive_transport.StopSending();
 
   Stop();
   DestroyStreams();
 }
 
 TEST_F(EndToEndTest, DISABLED_RestartingSendStreamPreservesRtpState) {
   TestRtpStatePreservation(false);
 }
 
 TEST_F(EndToEndTest, RestartingSendStreamPreservesRtpStatesWithRtx) {
@@ skipping 165 matching lines @@
     const rtc::scoped_ptr<EventWrapper> packet_event_;
     Call* sender_call_;
     Call* receiver_call_;
     NetworkState sender_state_ GUARDED_BY(test_crit_);
     int sender_rtp_ GUARDED_BY(test_crit_);
     int sender_rtcp_ GUARDED_BY(test_crit_);
     int receiver_rtcp_ GUARDED_BY(test_crit_);
     int down_frames_ GUARDED_BY(test_crit_);
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, CallReportsRttForSender) {
   static const int kSendDelayMs = 30;
   static const int kReceiveDelayMs = 70;
 
   CreateCalls(Call::Config(), Call::Config());
 
   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());
 
   CreateSendConfig(1, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
 
   CreateStreams();
   CreateFrameGeneratorCapturer();
   Start();
 
@@ skipping 41 matching lines @@
   SleepMs(kSilenceTimeoutMs);
   Stop();
 
   DestroyStreams();
 }
 
 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;
   CreateMatchingReceiveConfigs(&transport);
   CreateStreams();
   CreateFrameGeneratorCapturer();
 
   Start();
   SleepMs(kSilenceTimeoutMs);
   Stop();
@@ skipping 42 matching lines @@
   EXPECT_TRUE(default_receive_config.rtp.rtx.empty())
       << "Enabling RTX requires rtpmap: rtx negotiation.";
   EXPECT_TRUE(default_receive_config.rtp.extensions.empty())
       << "Enabling RTP extensions require negotiation.";
 
   VerifyEmptyNackConfig(default_receive_config.rtp.nack);
   VerifyEmptyFecConfig(default_receive_config.rtp.fec);
 }
 
 }  // namespace webrtc