Add send transports to individual webrtc::Call streams.

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 64 matching lines @@
   void ReceivesPliAndRecovers(int rtp_history_ms);
   void RespectsRtcpMode(newapi::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;
-  CreateCalls(Call::Config(&transport), Call::Config(&transport));
-
-  CreateSendConfig(1);
-  CreateMatchingReceiveConfigs();
+  CreateSendConfig(1, &transport);
+  CreateMatchingReceiveConfigs(&transport);
 
   CreateStreams();
 
   receive_streams_[0]->Start();
   receive_streams_[0]->Start();
 
   DestroyStreams();
 }
 
 TEST_F(EndToEndTest, ReceiverCanBeStoppedTwice) {
+  CreateCalls(Call::Config(), Call::Config());
+
   test::NullTransport transport;
-  CreateCalls(Call::Config(&transport), Call::Config(&transport));
-
-  CreateSendConfig(1);
-  CreateMatchingReceiveConfigs();
+  CreateSendConfig(1, &transport);
+  CreateMatchingReceiveConfigs(&transport);
 
   CreateStreams();
 
   receive_streams_[0]->Stop();
   receive_streams_[0]->Stop();
 
   DestroyStreams();
 }
 
 TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
@@ skipping 28 matching lines @@
 
    private:
     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;
-
-  CreateCalls(Call::Config(&sender_transport),
-              Call::Config(&receiver_transport));
-
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
-  CreateSendConfig(1);
-  CreateMatchingReceiveConfigs();
+  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;
 
   CreateStreams();
   Start();
 
   // Create frames that are smaller than the send width/height, this is done to
   // check that the callbacks are done after processing video.
@@ skipping 22 matching lines @@
                      int /*time_to_render_ms*/) override {
       event_->Set();
     }
     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;
-
-  CreateCalls(Call::Config(&sender_transport),
-              Call::Config(&receiver_transport));
-
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
-  CreateSendConfig(1);
-  CreateMatchingReceiveConfigs();
+  CreateSendConfig(1, &sender_transport);
+  CreateMatchingReceiveConfigs(&receiver_transport);
   receive_configs_[0].renderer = &renderer;
 
   CreateStreams();
   Start();
 
   rtc::scoped_ptr<test::FrameGenerator> frame_generator(
       test::FrameGenerator::CreateChromaGenerator(
           encoder_config_.streams[0].width, encoder_config_.streams[0].height));
   send_stream_->Input()->IncomingCapturedFrame(*frame_generator->NextFrame());
 
@@ skipping 409 matching lines @@
               nacks.begin(), nacks.end(), fec_sequence_number_) == nacks.end());
           observation_complete_->Set();
         }
       }
       return SEND_PACKET;
     }
 
     // TODO(holmer): Investigate why we don't send FEC packets when the bitrate
     // is 10 kbps.
     Call::Config GetSenderCallConfig() override {
-      Call::Config config(SendTransport());
+      Call::Config config;
       const int kMinBitrateBps = 30000;
       config.bitrate_config.min_bitrate_bps = kMinBitrateBps;
       return config;
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       // Configure hybrid NACK/FEC.
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
@@ skipping 185 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;
-
-  CreateCalls(Call::Config(&sender_transport),
-              Call::Config(&receiver_transport));
-
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
-  CreateSendConfig(1);
+  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;
   encoder_config_.streams[0].height = kHeight;
   send_config_.pre_encode_callback = &pre_encode_callback;
 
-  CreateMatchingReceiveConfigs();
+  CreateMatchingReceiveConfigs(&receiver_transport);
   receive_configs_[0].pre_render_callback = &pre_render_callback;
   receive_configs_[0].renderer = &renderer;
 
   CreateStreams();
   Start();
 
   // Create frames that are smaller than the send width/height, this is done to
   // check that the callbacks are done after processing video.
   rtc::scoped_ptr<test::FrameGenerator> frame_generator(
       test::FrameGenerator::CreateChromaGenerator(kWidth / 2, kHeight / 2));
@@ skipping 130 matching lines @@
         EXPECT_EQ(DELIVERY_UNKNOWN_SSRC, delivery_status);
         delivered_packet_->Set();
         return delivery_status;
       }
     }
 
     PacketReceiver* receiver_;
     rtc::scoped_ptr<EventWrapper> delivered_packet_;
   };
 
+  CreateCalls(Call::Config(), Call::Config());
+
   test::DirectTransport send_transport, receive_transport;
-
-  CreateCalls(Call::Config(&send_transport), Call::Config(&receive_transport));
   PacketInputObserver input_observer(receiver_call_->Receiver());
-
   send_transport.SetReceiver(&input_observer);
   receive_transport.SetReceiver(sender_call_->Receiver());
 
-  CreateSendConfig(1);
-  CreateMatchingReceiveConfigs();
+  CreateSendConfig(1, &send_transport);
+  CreateMatchingReceiveConfigs(&receive_transport);
 
   CreateStreams();
   CreateFrameGeneratorCapturer();
   Start();
 
   receiver_call_->DestroyVideoReceiveStream(receive_streams_[0]);
   receive_streams_.clear();
 
   // Wait() waits for a received packet.
   EXPECT_EQ(kEventSignaled, input_observer.Wait());
@@ skipping 111 matching lines @@
   }
 
   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(sender_transport.get())));
-    rtc::scoped_ptr<Call> receiver_call(
-        Call::Create(Call::Config(receiver_transport.get())));
+    rtc::scoped_ptr<Call> sender_call(Call::Create(Call::Config()));
+    rtc::scoped_ptr<Call> receiver_call(Call::Create(Call::Config()));
     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];
 
     test::FrameGeneratorCapturer* frame_generators[kNumStreams];
     ScopedVector<VideoDecoder> allocated_decoders;
     for (size_t i = 0; i < kNumStreams; ++i) {
       uint32_t ssrc = codec_settings[i].ssrc;
       int width = codec_settings[i].width;
       int height = codec_settings[i].height;
 
-      VideoSendStream::Config send_config;
+      VideoSendStream::Config send_config(sender_transport.get());
       send_config.rtp.ssrcs.push_back(ssrc);
       send_config.encoder_settings.encoder = encoders[i].get();
       send_config.encoder_settings.payload_name = "VP8";
       send_config.encoder_settings.payload_type = 124;
       VideoEncoderConfig encoder_config;
       encoder_config.streams = test::CreateVideoStreams(1);
       VideoStream* stream = &encoder_config.streams[0];
       stream->width = width;
       stream->height = height;
       stream->max_framerate = 5;
       stream->min_bitrate_bps = stream->target_bitrate_bps =
           stream->max_bitrate_bps = 100000;
 
       UpdateSendConfig(i, &send_config, &encoder_config, &frame_generators[i]);
 
       send_streams[i] =
           sender_call->CreateVideoSendStream(send_config, encoder_config);
       send_streams[i]->Start();
 
-      VideoReceiveStream::Config receive_config;
+      VideoReceiveStream::Config receive_config(receiver_transport.get());
       receive_config.rtp.remote_ssrc = ssrc;
       receive_config.rtp.local_ssrc = test::CallTest::kReceiverLocalSsrc;
       VideoReceiveStream::Decoder decoder =
           test::CreateMatchingDecoder(send_config.encoder_settings);
       allocated_decoders.push_back(decoder.decoder);
       receive_config.decoders.push_back(decoder);
 
       UpdateReceiveConfig(i, &receive_config);
 
       receive_streams[i] =
@@ skipping 258 matching lines @@
    private:
     rtc::scoped_ptr<uint8_t[]> buffer_;
     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;
-
-  CreateCalls(Call::Config(&sender_transport),
-              Call::Config(&receiver_transport));
-
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
-  CreateSendConfig(1);
-  CreateMatchingReceiveConfigs();
+  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();
 
   rtc::scoped_ptr<test::FrameGenerator> frame_generator(
       test::FrameGenerator::CreateChromaGenerator(
           encoder_config_.streams[0].width, encoder_config_.streams[0].height));
   send_stream_->Input()->IncomingCapturedFrame(*frame_generator->NextFrame());
@@ skipping 1111 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(observer.SendTransport()),
-              Call::Config(observer.ReceiveTransport()));
+  CreateCalls(Call::Config(), Call::Config());
   observer.SetReceivers(sender_call_->Receiver(), nullptr);
 
-  CreateSendConfig(kNumSsrcs);
+  CreateSendConfig(kNumSsrcs, observer.SendTransport());
 
   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();
+  CreateMatchingReceiveConfigs(observer.ReceiveTransport());
 
   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 217 matching lines @@
     int down_frames_ GUARDED_BY(test_crit_);
   } test;
 
   RunBaseTest(&test);
 }
 
 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);
   config.queue_delay_ms = kReceiveDelayMs;
   test::DirectTransport receiver_transport(config);
-
-  CreateCalls(Call::Config(&sender_transport),
-              Call::Config(&receiver_transport));
-
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
-  CreateSendConfig(1);
-  CreateMatchingReceiveConfigs();
+  CreateSendConfig(1, &sender_transport);
+  CreateMatchingReceiveConfigs(&receiver_transport);
 
   CreateStreams();
   CreateFrameGeneratorCapturer();
   Start();
 
   int64_t start_time_ms = clock_->TimeInMilliseconds();
   while (true) {
     Call::Stats stats = sender_call_->GetStats();
     ASSERT_GE(start_time_ms + kDefaultTimeoutMs,
               clock_->TimeInMilliseconds())
@@ skipping 15 matching lines @@
      UnusedEncoder() : FakeEncoder(Clock::GetRealTimeClock()) {}
      int32_t Encode(const VideoFrame& input_image,
                     const CodecSpecificInfo* codec_specific_info,
                     const std::vector<VideoFrameType>* frame_types) override {
       ADD_FAILURE() << "Unexpected frame encode.";
       return test::FakeEncoder::Encode(
           input_image, codec_specific_info, frame_types);
     }
   };
 
-  UnusedTransport transport;
-  CreateSenderCall(Call::Config(&transport));
+  CreateSenderCall(Call::Config());
   sender_call_->SignalNetworkState(kNetworkDown);
 
-  CreateSendConfig(1);
+  UnusedTransport transport;
+  CreateSendConfig(1, &transport);
   UnusedEncoder unused_encoder;
   send_config_.encoder_settings.encoder = &unused_encoder;
   CreateStreams();
   CreateFrameGeneratorCapturer();
 
   Start();
   SleepMs(kSilenceTimeoutMs);
   Stop();
 
   DestroyStreams();
 }
 
 TEST_F(EndToEndTest, NewReceiveStreamsRespectNetworkDown) {
-  test::DirectTransport sender_transport;
-  CreateSenderCall(Call::Config(&sender_transport));
-  UnusedTransport transport;
-  CreateReceiverCall(Call::Config(&transport));
-  sender_transport.SetReceiver(receiver_call_->Receiver());
-
+  CreateCalls(Call::Config(), Call::Config());
   receiver_call_->SignalNetworkState(kNetworkDown);
 
-  CreateSendConfig(1);
-  CreateMatchingReceiveConfigs();
+  test::DirectTransport sender_transport;
+  sender_transport.SetReceiver(receiver_call_->Receiver());
+  CreateSendConfig(1, &sender_transport);
+  UnusedTransport transport;
+  CreateMatchingReceiveConfigs(&transport);
   CreateStreams();
   CreateFrameGeneratorCapturer();
 
   Start();
   SleepMs(kSilenceTimeoutMs);
   Stop();
 
   sender_transport.StopSending();
 
   DestroyStreams();
 }
 
 // TODO(pbos): Remove this regression test when VideoEngine is no longer used as
 // a backend. This is to test that we hand channels back properly.
 TEST_F(EndToEndTest, CanCreateAndDestroyManyVideoStreams) {
   test::NullTransport transport;
-  rtc::scoped_ptr<Call> call(Call::Create(Call::Config(&transport)));
+  rtc::scoped_ptr<Call> call(Call::Create(Call::Config()));
   test::FakeDecoder fake_decoder;
   test::FakeEncoder fake_encoder(Clock::GetRealTimeClock());
   for (size_t i = 0; i < 100; ++i) {
-    VideoSendStream::Config send_config;
+    VideoSendStream::Config send_config(&transport);
     send_config.encoder_settings.encoder = &fake_encoder;
     send_config.encoder_settings.payload_name = "FAKE";
     send_config.encoder_settings.payload_type = 123;
 
     VideoEncoderConfig encoder_config;
     encoder_config.streams = test::CreateVideoStreams(1);
     send_config.rtp.ssrcs.push_back(1);
     VideoSendStream* send_stream =
         call->CreateVideoSendStream(send_config, encoder_config);
     call->DestroyVideoSendStream(send_stream);
 
-    VideoReceiveStream::Config receive_config;
+    VideoReceiveStream::Config receive_config(&transport);
     receive_config.rtp.remote_ssrc = 1;
     receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
     VideoReceiveStream::Decoder decoder;
     decoder.decoder = &fake_decoder;
     decoder.payload_type = 123;
     decoder.payload_name = "FAKE";
     receive_config.decoders.push_back(decoder);
     VideoReceiveStream* receive_stream =
         call->CreateVideoReceiveStream(receive_config);
     call->DestroyVideoReceiveStream(receive_stream);
   }
 }
 
 void VerifyEmptyNackConfig(const NackConfig& config) {
   EXPECT_EQ(0, config.rtp_history_ms)
       << "Enabling NACK requires rtcp-fb: nack negotiation.";
 }
 
 void VerifyEmptyFecConfig(const FecConfig& config) {
   EXPECT_EQ(-1, config.ulpfec_payload_type)
       << "Enabling FEC requires rtpmap: ulpfec negotiation.";
   EXPECT_EQ(-1, config.red_payload_type)
       << "Enabling FEC requires rtpmap: red negotiation.";
   EXPECT_EQ(-1, config.red_rtx_payload_type)
       << "Enabling RTX in FEC requires rtpmap: rtx negotiation.";
 }
 
 TEST_F(EndToEndTest, VerifyDefaultSendConfigParameters) {
-  VideoSendStream::Config default_send_config;
+  VideoSendStream::Config default_send_config(nullptr);
   EXPECT_EQ(0, default_send_config.rtp.nack.rtp_history_ms)
       << "Enabling NACK require rtcp-fb: nack negotiation.";
   EXPECT_TRUE(default_send_config.rtp.rtx.ssrcs.empty())
       << "Enabling RTX requires rtpmap: rtx negotiation.";
   EXPECT_TRUE(default_send_config.rtp.extensions.empty())
       << "Enabling RTP extensions require negotiation.";
 
   VerifyEmptyNackConfig(default_send_config.rtp.nack);
   VerifyEmptyFecConfig(default_send_config.rtp.fec);
 }
 
 TEST_F(EndToEndTest, VerifyDefaultReceiveConfigParameters) {
-  VideoReceiveStream::Config default_receive_config;
+  VideoReceiveStream::Config default_receive_config(nullptr);
   EXPECT_EQ(newapi::kRtcpCompound, default_receive_config.rtp.rtcp_mode)
       << "Reduced-size RTCP require rtcp-rsize to be negotiated.";
   EXPECT_FALSE(default_receive_config.rtp.remb)
       << "REMB require rtcp-fb: goog-remb to be negotiated.";
   EXPECT_FALSE(
       default_receive_config.rtp.rtcp_xr.receiver_reference_time_report)
       << "RTCP XR settings require rtcp-xr to be negotiated.";
   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