Add send transports to individual webrtc::Call streams.

webrtc/video/rampup_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.
  */
 
@@ skipping 363 matching lines @@
                                bool rtx,
                                bool red) {
   std::vector<uint32_t> ssrcs(GenerateSsrcs(num_streams, 100));
   std::vector<uint32_t> rtx_ssrcs(GenerateSsrcs(num_streams, 200));
   StreamObserver::SsrcMap rtx_ssrc_map;
   if (rtx) {
     for (size_t i = 0; i < ssrcs.size(); ++i)
       rtx_ssrc_map[rtx_ssrcs[i]] = ssrcs[i];
   }
 
-  CreateSendConfig(num_streams);
-  send_config_.rtp.extensions.clear();
-
   test::DirectTransport receiver_transport;
   StreamObserver stream_observer(rtx_ssrc_map, &receiver_transport,
                                  Clock::GetRealTimeClock());
 
+  CreateSendConfig(num_streams, &stream_observer);
+  send_config_.rtp.extensions.clear();
+
   if (extension_type == RtpExtension::kAbsSendTime) {
     stream_observer.SetRemoteBitrateEstimator(
         new RemoteBitrateEstimatorAbsSendTime(
             &stream_observer, Clock::GetRealTimeClock(),
             kRemoteBitrateEstimatorMinBitrateBps));
     send_config_.rtp.extensions.push_back(RtpExtension(
         extension_type.c_str(), kAbsSendTimeExtensionId));
   } else {
     stream_observer.SetRemoteBitrateEstimator(
         new RemoteBitrateEstimatorSingleStream(
             &stream_observer, Clock::GetRealTimeClock(),
             kRemoteBitrateEstimatorMinBitrateBps));
     send_config_.rtp.extensions.push_back(RtpExtension(
         extension_type.c_str(), kTransmissionTimeOffsetExtensionId));
   }
 
-  Call::Config call_config(&stream_observer);
+  Call::Config call_config;
   if (start_bitrate_bps != 0) {
     call_config.bitrate_config.start_bitrate_bps = start_bitrate_bps;
     stream_observer.set_start_bitrate_bps(start_bitrate_bps);
   }
-
   CreateSenderCall(call_config);
 
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   if (num_streams == 1) {
     encoder_config_.streams[0].target_bitrate_bps = 2000000;
     encoder_config_.streams[0].max_bitrate_bps = 2000000;
   }
 
   send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
@@ skipping 32 matching lines @@
   DestroyStreams();
 }
 
 void RampUpTest::RunRampUpDownUpTest(size_t number_of_streams,
                                      bool rtx,
                                      bool red) {
   test::DirectTransport receiver_transport;
   LowRateStreamObserver stream_observer(
       &receiver_transport, Clock::GetRealTimeClock(), number_of_streams, rtx);
 
-  Call::Config call_config(&stream_observer);
+  Call::Config call_config;
   call_config.bitrate_config.start_bitrate_bps = 60000;
   CreateSenderCall(call_config);
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
-  CreateSendConfig(number_of_streams);
+  CreateSendConfig(number_of_streams, &stream_observer);
 
   send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
   send_config_.rtp.extensions.push_back(RtpExtension(
       RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
   send_config_.suspend_below_min_bitrate = true;
 
   if (rtx) {
     send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
     send_config_.rtp.rtx.ssrcs = GenerateSsrcs(number_of_streams, 200);
   }
@@ skipping 74 matching lines @@
 
 TEST_F(RampUpTest, AbsSendTimeSimulcastByRedWithRtx) {
   RunRampUpTest(3, 0, RtpExtension::kAbsSendTime, true, true);
 }
 
 TEST_F(RampUpTest, AbsSendTimeSingleStreamWithHighStartBitrate) {
   RunRampUpTest(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kAbsSendTime,
                 false, false);
 }
 }  // namespace webrtc