Add send transports to individual webrtc::Call streams.

webrtc/video/video_send_stream_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>  // max
@@ skipping 41 matching lines @@
 VideoFrame CreateVideoFrame(int width, int height, uint8_t data);
 
 class VideoSendStreamTest : public test::CallTest {
  protected:
   void TestNackRetransmission(uint32_t retransmit_ssrc,
                               uint8_t retransmit_payload_type);
   void TestPacketFragmentationSize(VideoFormat format, bool with_fec);
 };
 
 TEST_F(VideoSendStreamTest, CanStartStartedStream) {
-  test::NullTransport transport;
-  Call::Config call_config(&transport);
+  Call::Config call_config;
   CreateSenderCall(call_config);
 
-  CreateSendConfig(1);
+  test::NullTransport transport;
+  CreateSendConfig(1, &transport);
   CreateStreams();
   send_stream_->Start();
   send_stream_->Start();
   DestroyStreams();
 }
 
 TEST_F(VideoSendStreamTest, CanStopStoppedStream) {
-  test::NullTransport transport;
-  Call::Config call_config(&transport);
+  Call::Config call_config;
   CreateSenderCall(call_config);
 
-  CreateSendConfig(1);
+  test::NullTransport transport;
+  CreateSendConfig(1, &transport);
   CreateStreams();
   send_stream_->Stop();
   send_stream_->Stop();
   DestroyStreams();
 }
 
 TEST_F(VideoSendStreamTest, SupportsCName) {
   static std::string kCName = "PjQatC14dGfbVwGPUOA9IH7RlsFDbWl4AhXEiDsBizo=";
   class CNameObserver : public test::SendTest {
    public:
@@ skipping 518 matching lines @@
       // Increase frame size for next encoded frame, in the context of the
       // encoder thread.
       if (!use_fec_ &&
           current_size_frame_.Value() < static_cast<int32_t>(stop_size_)) {
         ++current_size_frame_;
       }
       encoder_.SetFrameSize(static_cast<size_t>(current_size_frame_.Value()));
     }
 
     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 {
       if (use_fec_) {
         send_config->rtp.fec.red_payload_type = kRedPayloadType;
@@ skipping 409 matching lines @@
     int GetStartBitrateKbps() const {
       rtc::CritScope lock(&crit_);
       return start_bitrate_kbps_;
     }
 
    private:
     mutable rtc::CriticalSection crit_;
     int start_bitrate_kbps_ GUARDED_BY(crit_);
   };
 
+  CreateSenderCall(Call::Config());
+
   test::NullTransport transport;
-  CreateSenderCall(Call::Config(&transport));
-
-  CreateSendConfig(1);
+  CreateSendConfig(1, &transport);
 
   Call::Config::BitrateConfig bitrate_config;
   bitrate_config.start_bitrate_bps =
       2 * encoder_config_.streams[0].max_bitrate_bps;
   sender_call_->SetBitrateConfig(bitrate_config);
 
   StartBitrateObserver encoder;
   send_config_.encoder_settings.encoder = &encoder;
 
   CreateStreams();
@@ skipping 36 matching lines @@
 
    private:
     // Delivered output frames.
     std::vector<VideoFrame> output_frames_;
 
     // Indicate an output frame has arrived.
     rtc::scoped_ptr<EventWrapper> output_frame_event_;
   };
 
   // Initialize send stream.
+  CreateSenderCall(Call::Config());
+
   test::NullTransport transport;
-  CreateSenderCall(Call::Config(&transport));
-
-  CreateSendConfig(1);
+  CreateSendConfig(1, &transport);
   FrameObserver observer;
   send_config_.pre_encode_callback = &observer;
   CreateStreams();
 
   // Prepare five input frames. Send ordinary VideoFrame and texture frames
   // alternatively.
   std::vector<VideoFrame> input_frames;
   int width = static_cast<int>(encoder_config_.streams[0].width);
   int height = static_cast<int>(encoder_config_.streams[0].height);
   test::FakeNativeHandle* handle1 = new test::FakeNativeHandle();
@@ skipping 531 matching lines @@
                   codecSettings->maxBitrate);
         EXPECT_EQ(static_cast<unsigned int>(kIncreasedStartBitrateKbps),
                   codecSettings->startBitrate);
       }
       ++num_initializations_;
       return FakeEncoder::InitEncode(codecSettings, numberOfCores,
                                      maxPayloadSize);
     }
 
     Call::Config GetSenderCallConfig() override {
-      Call::Config config(SendTransport());
+      Call::Config config;
       config.bitrate_config.min_bitrate_bps = kMinBitrateKbps * 1000;
       config.bitrate_config.start_bitrate_bps = kStartBitrateKbps * 1000;
       config.bitrate_config.max_bitrate_bps = kMaxBitrateKbps * 1000;
       return config;
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder = this;
@@ skipping 116 matching lines @@
         const std::vector<VideoReceiveStream*>& receive_streams) override {
       send_stream_ = send_stream;
     }
 
     VideoSendStream* send_stream_;
   } test;
 
   RunBaseTest(&test);
 }
 }  // namespace webrtc