Make VideoSendStream/VideoReceiveStream configs const.

Benefits of this is that the send config previously had unclear locking
requirements, a lock was used to lock parts parts of it while
reconfiguring the VideoEncoder. Primary work was splitting out video
streams from config as well as encoder_settings as these change on
ReconfigureVideoEncoder. Now threading requirements for both member
configs are clear (as they are read-only), and encoder_settings doesn't
stay in the config as a stale pointer.

CreateVideoSendStream now takes video streams separately as well as the
encoder_settings pointer, analogous to ReconfigureVideoEncoder.

This change required changing so that pacing is silently enabled when
using suspend_below_min_bitrate rather than silently setting it.

R=henrik.lundin@webrtc.org, mflodman@webrtc.org, pthatcher@webrtc.org, stefan@webrtc.org
BUG=3260

Review URL: https://webrtc-codereview.appspot.com/20409004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@6349 4adac7df-926f-26a2-2b94-8c16560cd09d
diff --git a/webrtc/call.h b/webrtc/call.h
index 53b17ed..1771ad8 100644
--- a/webrtc/call.h
+++ b/webrtc/call.h
@@ -83,7 +83,9 @@
   virtual VideoSendStream::Config GetDefaultSendConfig() = 0;
 
   virtual VideoSendStream* CreateVideoSendStream(
-      const VideoSendStream::Config& config) = 0;
+      const VideoSendStream::Config& config,
+      const std::vector<VideoStream>& video_streams,
+      const void* encoder_settings) = 0;
 
   virtual void DestroyVideoSendStream(VideoSendStream* send_stream) = 0;
 
diff --git a/webrtc/test/encoder_settings.cc b/webrtc/test/encoder_settings.cc
index d02c29f..5193be6 100644
--- a/webrtc/test/encoder_settings.cc
+++ b/webrtc/test/encoder_settings.cc
@@ -16,18 +16,14 @@
 
 namespace webrtc {
 namespace test {
-VideoSendStream::Config::EncoderSettings CreateEncoderSettings(
-    VideoEncoder* encoder,
-    const char* payload_name,
-    int payload_type,
-    size_t num_streams) {
+std::vector<VideoStream> CreateVideoStreams(size_t num_streams) {
   assert(num_streams > 0);
 
   // Add more streams to the settings above with reasonable values if required.
   static const size_t kNumSettings = 3;
   assert(num_streams <= kNumSettings);
 
-  VideoStream stream_settings[kNumSettings];
+  std::vector<VideoStream> stream_settings(kNumSettings);
 
   stream_settings[0].width = 320;
   stream_settings[0].height = 180;
@@ -52,28 +48,20 @@
   stream_settings[2].target_bitrate_bps = stream_settings[2].max_bitrate_bps =
       1500000;
   stream_settings[2].max_qp = 56;
-
-  VideoSendStream::Config::EncoderSettings settings;
-
-  for (size_t i = 0; i < num_streams; ++i)
-    settings.streams.push_back(stream_settings[i]);
-
-  settings.encoder = encoder;
-  settings.payload_name = payload_name;
-  settings.payload_type = payload_type;
-  return settings;
+  stream_settings.resize(num_streams);
+  return stream_settings;
 }
 
 VideoCodec CreateDecoderVideoCodec(
-    const VideoSendStream::Config::EncoderSettings& settings) {
-  assert(settings.streams.size() > 0);
+    const VideoSendStream::Config::EncoderSettings& encoder_settings) {
   VideoCodec codec;
   memset(&codec, 0, sizeof(codec));
 
-  codec.plType = settings.payload_type;
-  strcpy(codec.plName, settings.payload_name.c_str());
+  codec.plType = encoder_settings.payload_type;
+  strcpy(codec.plName, encoder_settings.payload_name.c_str());
   codec.codecType =
-      (settings.payload_name == "VP8" ? kVideoCodecVP8 : kVideoCodecGeneric);
+      (encoder_settings.payload_name == "VP8" ? kVideoCodecVP8
+                                              : kVideoCodecGeneric);
 
   if (codec.codecType == kVideoCodecVP8) {
     codec.codecSpecific.VP8.resilience = kResilientStream;
@@ -85,33 +73,9 @@
     codec.codecSpecific.VP8.keyFrameInterval = 3000;
   }
 
-  codec.minBitrate = settings.streams[0].min_bitrate_bps / 1000;
-  for (size_t i = 0; i < settings.streams.size(); ++i) {
-    const VideoStream& stream = settings.streams[i];
-    if (stream.width > codec.width)
-      codec.width = static_cast<unsigned short>(stream.width);
-    if (stream.height > codec.height)
-      codec.height = static_cast<unsigned short>(stream.height);
-    if (static_cast<unsigned int>(stream.min_bitrate_bps / 1000) <
-        codec.minBitrate)
-      codec.minBitrate =
-          static_cast<unsigned int>(stream.min_bitrate_bps / 1000);
-    codec.maxBitrate += stream.max_bitrate_bps / 1000;
-    if (static_cast<unsigned int>(stream.max_qp) > codec.qpMax)
-      codec.qpMax = static_cast<unsigned int>(stream.max_qp);
-  }
-
-  if (codec.minBitrate < kViEMinCodecBitrate)
-    codec.minBitrate = kViEMinCodecBitrate;
-  if (codec.maxBitrate < kViEMinCodecBitrate)
-    codec.maxBitrate = kViEMinCodecBitrate;
-
-  codec.startBitrate = 300;
-
-  if (codec.startBitrate < codec.minBitrate)
-    codec.startBitrate = codec.minBitrate;
-  if (codec.startBitrate > codec.maxBitrate)
-    codec.startBitrate = codec.maxBitrate;
+  codec.width = 320;
+  codec.height = 180;
+  codec.startBitrate = codec.minBitrate = codec.maxBitrate = 300;
 
   return codec;
 }
diff --git a/webrtc/test/encoder_settings.h b/webrtc/test/encoder_settings.h
index 1d8e355..ea2be97 100644
--- a/webrtc/test/encoder_settings.h
+++ b/webrtc/test/encoder_settings.h
@@ -14,14 +14,10 @@
 
 namespace webrtc {
 namespace test {
-VideoSendStream::Config::EncoderSettings CreateEncoderSettings(
-    VideoEncoder* encoder,
-    const char* payload_name,
-    int payload_type,
-    size_t num_streams);
+std::vector<VideoStream> CreateVideoStreams(size_t num_streams);
 
 VideoCodec CreateDecoderVideoCodec(
-    const VideoSendStream::Config::EncoderSettings& settings);
+    const VideoSendStream::Config::EncoderSettings& encoder_settings);
 }  // namespace test
 }  // namespace webrtc
 
diff --git a/webrtc/video/bitrate_estimator_tests.cc b/webrtc/video/bitrate_estimator_tests.cc
index 7b74818..f8b9060 100644
--- a/webrtc/video/bitrate_estimator_tests.cc
+++ b/webrtc/video/bitrate_estimator_tests.cc
@@ -70,8 +70,10 @@
     send_config_ = sender_call_->GetDefaultSendConfig();
     send_config_.rtp.ssrcs.push_back(kSendSsrc);
     // Encoders will be set separately per stream.
-    send_config_.encoder_settings =
-        test::CreateEncoderSettings(NULL, "FAKE", kSendPayloadType, 1);
+    send_config_.encoder_settings.encoder = NULL;
+    send_config_.encoder_settings.payload_name = "FAKE";
+    send_config_.encoder_settings.payload_type = kSendPayloadType;
+    video_streams_ = test::CreateVideoStreams(1);
 
     receive_config_ = receiver_call_->GetDefaultReceiveConfig();
     assert(receive_config_.codecs.empty());
@@ -169,15 +171,15 @@
           fake_decoder_() {
       test_->send_config_.rtp.ssrcs[0]++;
       test_->send_config_.encoder_settings.encoder = &fake_encoder_;
-      send_stream_ =
-          test_->sender_call_->CreateVideoSendStream(test_->send_config_);
-      assert(test_->send_config_.encoder_settings.streams.size() == 1);
-      frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create(
-          send_stream_->Input(),
-          test_->send_config_.encoder_settings.streams[0].width,
-          test_->send_config_.encoder_settings.streams[0].height,
-          30,
-          Clock::GetRealTimeClock()));
+      send_stream_ = test_->sender_call_->CreateVideoSendStream(
+          test_->send_config_, test_->video_streams_, NULL);
+      assert(test_->video_streams_.size() == 1);
+      frame_generator_capturer_.reset(
+          test::FrameGeneratorCapturer::Create(send_stream_->Input(),
+                                               test_->video_streams_[0].width,
+                                               test_->video_streams_[0].height,
+                                               30,
+                                               Clock::GetRealTimeClock()));
       send_stream_->Start();
       frame_generator_capturer_->Start();
 
@@ -227,6 +229,7 @@
   scoped_ptr<Call> sender_call_;
   scoped_ptr<Call> receiver_call_;
   VideoSendStream::Config send_config_;
+  std::vector<VideoStream> video_streams_;
   VideoReceiveStream::Config receive_config_;
   std::vector<Stream*> streams_;
 };
diff --git a/webrtc/video/call.cc b/webrtc/video/call.cc
index 6adb0fc..6103074 100644
--- a/webrtc/video/call.cc
+++ b/webrtc/video/call.cc
@@ -70,7 +70,9 @@
   virtual VideoSendStream::Config GetDefaultSendConfig() OVERRIDE;
 
   virtual VideoSendStream* CreateVideoSendStream(
-      const VideoSendStream::Config& config) OVERRIDE;
+      const VideoSendStream::Config& config,
+      const std::vector<VideoStream>& video_streams,
+      const void* encoder_settings) OVERRIDE;
 
   virtual void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream)
       OVERRIDE;
@@ -175,15 +177,19 @@
 }
 
 VideoSendStream* Call::CreateVideoSendStream(
-    const VideoSendStream::Config& config) {
+    const VideoSendStream::Config& config,
+    const std::vector<VideoStream>& video_streams,
+    const void* encoder_settings) {
   assert(config.rtp.ssrcs.size() > 0);
 
-  VideoSendStream* send_stream = new VideoSendStream(
-      config_.send_transport,
-      overuse_observer_proxy_.get(),
-      video_engine_,
-      config,
-      base_channel_id_);
+  VideoSendStream* send_stream =
+      new VideoSendStream(config_.send_transport,
+                          overuse_observer_proxy_.get(),
+                          video_engine_,
+                          config,
+                          video_streams,
+                          encoder_settings,
+                          base_channel_id_);
 
   WriteLockScoped write_lock(*send_lock_);
   for (size_t i = 0; i < config.rtp.ssrcs.size(); ++i) {
diff --git a/webrtc/video/call_perf_tests.cc b/webrtc/video/call_perf_tests.cc
index bc0a1e0..f9e44ae 100644
--- a/webrtc/video/call_perf_tests.cc
+++ b/webrtc/video/call_perf_tests.cc
@@ -53,18 +53,19 @@
       : send_stream_(NULL), fake_encoder_(Clock::GetRealTimeClock()) {}
 
  protected:
-  VideoSendStream::Config GetSendTestConfig(Call* call) {
-    VideoSendStream::Config config = call->GetDefaultSendConfig();
-    config.rtp.ssrcs.push_back(kSendSsrc);
-    config.encoder_settings = test::CreateEncoderSettings(
-        &fake_encoder_, "FAKE", kSendPayloadType, 1);
-    return config;
+  void CreateTestConfig(Call* call) {
+    send_config_ = call->GetDefaultSendConfig();
+    send_config_.rtp.ssrcs.push_back(kSendSsrc);
+    send_config_.encoder_settings.encoder = &fake_encoder_;
+    send_config_.encoder_settings.payload_type = kSendPayloadType;
+    send_config_.encoder_settings.payload_name = "FAKE";
+    video_streams_ = test::CreateVideoStreams(1);
   }
 
   void RunVideoSendTest(Call* call,
                         const VideoSendStream::Config& config,
                         test::RtpRtcpObserver* observer) {
-    send_stream_ = call->CreateVideoSendStream(config);
+    send_stream_ = call->CreateVideoSendStream(config, video_streams_, NULL);
     scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
         test::FrameGeneratorCapturer::Create(
             send_stream_->Input(), 320, 240, 30, Clock::GetRealTimeClock()));
@@ -86,6 +87,8 @@
                           int start_time_ms,
                           int run_time_ms);
 
+  VideoSendStream::Config send_config_;
+  std::vector<VideoStream> video_streams_;
   VideoSendStream* send_stream_;
   test::FakeEncoder fake_encoder_;
 };
@@ -288,35 +291,34 @@
 
   test::FakeDecoder fake_decoder;
 
-  VideoSendStream::Config send_config = GetSendTestConfig(sender_call.get());
+  CreateTestConfig(sender_call.get());
 
   VideoReceiveStream::Config receive_config =
       receiver_call->GetDefaultReceiveConfig();
   assert(receive_config.codecs.empty());
   VideoCodec codec =
-      test::CreateDecoderVideoCodec(send_config.encoder_settings);
+      test::CreateDecoderVideoCodec(send_config_.encoder_settings);
   receive_config.codecs.push_back(codec);
   assert(receive_config.external_decoders.empty());
   ExternalVideoDecoder decoder;
   decoder.decoder = &fake_decoder;
-  decoder.payload_type = send_config.encoder_settings.payload_type;
+  decoder.payload_type = send_config_.encoder_settings.payload_type;
   receive_config.external_decoders.push_back(decoder);
-  receive_config.rtp.remote_ssrc = send_config.rtp.ssrcs[0];
+  receive_config.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
   receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
   receive_config.renderer = &observer;
   receive_config.audio_channel_id = channel;
 
   VideoSendStream* send_stream =
-      sender_call->CreateVideoSendStream(send_config);
+      sender_call->CreateVideoSendStream(send_config_, video_streams_, NULL);
   VideoReceiveStream* receive_stream =
       receiver_call->CreateVideoReceiveStream(receive_config);
   scoped_ptr<test::FrameGeneratorCapturer> capturer(
-      test::FrameGeneratorCapturer::Create(
-          send_stream->Input(),
-          send_config.encoder_settings.streams[0].width,
-          send_config.encoder_settings.streams[0].height,
-          30,
-          Clock::GetRealTimeClock()));
+      test::FrameGeneratorCapturer::Create(send_stream->Input(),
+                                           video_streams_[0].width,
+                                           video_streams_[0].height,
+                                           30,
+                                           Clock::GetRealTimeClock()));
   receive_stream->Start();
   send_stream->Start();
   capturer->Start();
@@ -465,16 +467,15 @@
   observer.SetReceivers(receiver_call->Receiver(), sender_call->Receiver());
 
   // Configure send stream.
-  VideoSendStream::Config send_config = GetSendTestConfig(sender_call.get());
+  CreateTestConfig(sender_call.get());
   VideoSendStream* send_stream =
-      sender_call->CreateVideoSendStream(send_config);
+      sender_call->CreateVideoSendStream(send_config_, video_streams_, NULL);
   scoped_ptr<test::FrameGeneratorCapturer> capturer(
-      test::FrameGeneratorCapturer::Create(
-          send_stream->Input(),
-          send_config.encoder_settings.streams[0].width,
-          send_config.encoder_settings.streams[0].height,
-          30,
-          Clock::GetRealTimeClock()));
+      test::FrameGeneratorCapturer::Create(send_stream->Input(),
+                                           video_streams_[0].width,
+                                           video_streams_[0].height,
+                                           30,
+                                           Clock::GetRealTimeClock()));
   observer.SetCapturer(capturer.get());
 
   // Configure receive stream.
@@ -482,15 +483,15 @@
       receiver_call->GetDefaultReceiveConfig();
   assert(receive_config.codecs.empty());
   VideoCodec codec =
-      test::CreateDecoderVideoCodec(send_config.encoder_settings);
+      test::CreateDecoderVideoCodec(send_config_.encoder_settings);
   receive_config.codecs.push_back(codec);
   assert(receive_config.external_decoders.empty());
   ExternalVideoDecoder decoder;
   test::FakeDecoder fake_decoder;
   decoder.decoder = &fake_decoder;
-  decoder.payload_type = send_config.encoder_settings.payload_type;
+  decoder.payload_type = send_config_.encoder_settings.payload_type;
   receive_config.external_decoders.push_back(decoder);
-  receive_config.rtp.remote_ssrc = send_config.rtp.ssrcs[0];
+  receive_config.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
   receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
   receive_config.renderer = &observer;
   // Enable the receiver side rtt calculation.
@@ -559,8 +560,8 @@
   call_config.overuse_callback = &observer;
   scoped_ptr<Call> call(Call::Create(call_config));
 
-  VideoSendStream::Config send_config = GetSendTestConfig(call.get());
-  RunVideoSendTest(call.get(), send_config, &observer);
+  CreateTestConfig(call.get());
+  RunVideoSendTest(call.get(), send_config_, &observer);
 }
 
 void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
@@ -636,43 +637,42 @@
   scoped_ptr<Call> receiver_call(
       Call::Create(Call::Config(observer.ReceiveTransport())));
 
-  VideoSendStream::Config send_config = GetSendTestConfig(sender_call.get());
+  CreateTestConfig(sender_call.get());
   fake_encoder_.SetMaxBitrate(kMaxEncodeBitrateKbps);
 
   observer.SetReceivers(receiver_call->Receiver(), sender_call->Receiver());
 
-  send_config.pacing = true;
+  send_config_.pacing = true;
   if (pad_to_min_bitrate) {
-    send_config.rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
+    send_config_.rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
   } else {
-    assert(send_config.rtp.min_transmit_bitrate_bps == 0);
+    assert(send_config_.rtp.min_transmit_bitrate_bps == 0);
   }
 
   VideoReceiveStream::Config receive_config =
       receiver_call->GetDefaultReceiveConfig();
   receive_config.codecs.clear();
   VideoCodec codec =
-      test::CreateDecoderVideoCodec(send_config.encoder_settings);
+      test::CreateDecoderVideoCodec(send_config_.encoder_settings);
   receive_config.codecs.push_back(codec);
   test::FakeDecoder fake_decoder;
   ExternalVideoDecoder decoder;
   decoder.decoder = &fake_decoder;
-  decoder.payload_type = send_config.encoder_settings.payload_type;
+  decoder.payload_type = send_config_.encoder_settings.payload_type;
   receive_config.external_decoders.push_back(decoder);
-  receive_config.rtp.remote_ssrc = send_config.rtp.ssrcs[0];
+  receive_config.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
   receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
 
   VideoSendStream* send_stream =
-      sender_call->CreateVideoSendStream(send_config);
+      sender_call->CreateVideoSendStream(send_config_, video_streams_, NULL);
   VideoReceiveStream* receive_stream =
       receiver_call->CreateVideoReceiveStream(receive_config);
   scoped_ptr<test::FrameGeneratorCapturer> capturer(
-      test::FrameGeneratorCapturer::Create(
-          send_stream->Input(),
-          send_config.encoder_settings.streams[0].width,
-          send_config.encoder_settings.streams[0].height,
-          30,
-          Clock::GetRealTimeClock()));
+      test::FrameGeneratorCapturer::Create(send_stream->Input(),
+                                           video_streams_[0].width,
+                                           video_streams_[0].height,
+                                           30,
+                                           Clock::GetRealTimeClock()));
   observer.SetSendStream(send_stream);
   receive_stream->Start();
   send_stream->Start();
diff --git a/webrtc/video/call_tests.cc b/webrtc/video/call_tests.cc
index 7b78af3..5bcf115 100644
--- a/webrtc/video/call_tests.cc
+++ b/webrtc/video/call_tests.cc
@@ -73,8 +73,10 @@
     receive_config_ = receiver_call_->GetDefaultReceiveConfig();
 
     send_config_.rtp.ssrcs.push_back(kSendSsrc);
-    send_config_.encoder_settings = test::CreateEncoderSettings(
-        &fake_encoder_, "FAKE", kSendPayloadType, 1);
+    send_config_.encoder_settings.encoder = &fake_encoder_;
+    send_config_.encoder_settings.payload_name = "FAKE";
+    send_config_.encoder_settings.payload_type = kSendPayloadType;
+    video_streams_ = test::CreateVideoStreams(1);
 
     assert(receive_config_.codecs.empty());
     VideoCodec codec =
@@ -92,17 +94,18 @@
     assert(send_stream_ == NULL);
     assert(receive_stream_ == NULL);
 
-    send_stream_ = sender_call_->CreateVideoSendStream(send_config_);
+    send_stream_ =
+        sender_call_->CreateVideoSendStream(send_config_, video_streams_, NULL);
     receive_stream_ = receiver_call_->CreateVideoReceiveStream(receive_config_);
   }
 
   void CreateFrameGenerator() {
-    frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create(
-        send_stream_->Input(),
-        send_config_.encoder_settings.streams[0].width,
-        send_config_.encoder_settings.streams[0].height,
-        30,
-        Clock::GetRealTimeClock()));
+    frame_generator_capturer_.reset(
+        test::FrameGeneratorCapturer::Create(send_stream_->Input(),
+                                             video_streams_[0].width,
+                                             video_streams_[0].height,
+                                             30,
+                                             Clock::GetRealTimeClock()));
   }
 
   void StartSending() {
@@ -139,6 +142,7 @@
   scoped_ptr<Call> receiver_call_;
 
   VideoSendStream::Config send_config_;
+  std::vector<VideoStream> video_streams_;
   VideoReceiveStream::Config receive_config_;
 
   VideoSendStream* send_stream_;
@@ -350,8 +354,7 @@
   StartSending();
 
   scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
-      send_config_.encoder_settings.streams[0].width,
-      send_config_.encoder_settings.streams[0].height));
+      video_streams_[0].width, video_streams_[0].height));
   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 
   EXPECT_EQ(kEventSignaled, renderer.Wait())
@@ -701,10 +704,9 @@
   scoped_ptr<VP8Encoder> encoder(VP8Encoder::Create());
   send_config_.encoder_settings.encoder = encoder.get();
   send_config_.encoder_settings.payload_name = "VP8";
-  ASSERT_EQ(1u, send_config_.encoder_settings.streams.size())
-      << "Test setup error.";
-  send_config_.encoder_settings.streams[0].width = kWidth;
-  send_config_.encoder_settings.streams[0].height = kHeight;
+  ASSERT_EQ(1u, video_streams_.size()) << "Test setup error.";
+  video_streams_[0].width = kWidth;
+  video_streams_[0].height = kHeight;
   send_config_.pre_encode_callback = &pre_encode_callback;
   receive_config_.codecs.clear();
   VideoCodec codec =
@@ -1055,15 +1057,18 @@
 
     VideoSendStream::Config send_config = sender_call->GetDefaultSendConfig();
     send_config.rtp.ssrcs.push_back(ssrc);
-    send_config.encoder_settings =
-        test::CreateEncoderSettings(encoders[i].get(), "VP8", 124, 1);
-    VideoStream* stream = &send_config.encoder_settings.streams[0];
+    send_config.encoder_settings.encoder = encoders[i].get();
+    send_config.encoder_settings.payload_name = "VP8";
+    send_config.encoder_settings.payload_type = 124;
+    std::vector<VideoStream> video_streams = test::CreateVideoStreams(1);
+    VideoStream* stream = &video_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;
-    send_streams[i] = sender_call->CreateVideoSendStream(send_config);
+    send_streams[i] =
+        sender_call->CreateVideoSendStream(send_config, video_streams, NULL);
     send_streams[i]->Start();
 
     VideoReceiveStream::Config receive_config =
@@ -1154,8 +1159,7 @@
   StartSending();
 
   scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
-      send_config_.encoder_settings.streams[0].width,
-      send_config_.encoder_settings.streams[0].height));
+      video_streams_[0].width, video_streams_[0].height));
   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 
   EXPECT_EQ(kEventSignaled, post_encode_observer.Wait())
diff --git a/webrtc/video/full_stack.cc b/webrtc/video/full_stack.cc
index cb97cd8..6b21cbe 100644
--- a/webrtc/video/full_stack.cc
+++ b/webrtc/video/full_stack.cc
@@ -398,16 +398,19 @@
   send_config.rtp.ssrcs.push_back(kSendSsrc);
 
   scoped_ptr<VP8Encoder> encoder(VP8Encoder::Create());
-  send_config.encoder_settings =
-      test::CreateEncoderSettings(encoder.get(), "VP8", 124, 1);
-  VideoStream* stream = &send_config.encoder_settings.streams[0];
+  send_config.encoder_settings.encoder = encoder.get();
+  send_config.encoder_settings.payload_name = "VP8";
+  send_config.encoder_settings.payload_type = 124;
+  std::vector<VideoStream> video_streams = test::CreateVideoStreams(1);
+  VideoStream* stream = &video_streams[0];
   stream->width = params.clip.width;
   stream->height = params.clip.height;
   stream->min_bitrate_bps = stream->target_bitrate_bps =
       stream->max_bitrate_bps = params.bitrate * 1000;
   stream->max_framerate = params.clip.fps;
 
-  VideoSendStream* send_stream = call->CreateVideoSendStream(send_config);
+  VideoSendStream* send_stream =
+      call->CreateVideoSendStream(send_config, video_streams, NULL);
   analyzer.input_ = send_stream->Input();
 
   scoped_ptr<test::FrameGeneratorCapturer> file_capturer(
diff --git a/webrtc/video/loopback.cc b/webrtc/video/loopback.cc
index eb2d5ae..ecc2089 100644
--- a/webrtc/video/loopback.cc
+++ b/webrtc/video/loopback.cc
@@ -72,19 +72,21 @@
   send_config.local_renderer = local_preview.get();
 
   scoped_ptr<VP8Encoder> encoder(VP8Encoder::Create());
-  send_config.encoder_settings =
-      test::CreateEncoderSettings(encoder.get(), "VP8", 124, 1);
-  VideoStream* stream = &send_config.encoder_settings.streams[0];
+  send_config.encoder_settings.encoder = encoder.get();
+  send_config.encoder_settings.payload_name = "VP8";
+  send_config.encoder_settings.payload_type = 124;
+  std::vector<VideoStream> video_streams = test::CreateVideoStreams(1);
+  VideoStream* stream = &video_streams[0];
   stream->width = flags::Width();
   stream->height = flags::Height();
   stream->min_bitrate_bps = static_cast<int>(flags::MinBitrate()) * 1000;
-  stream->target_bitrate_bps =
-      static_cast<int>(flags::MaxBitrate()) * 1000;
+  stream->target_bitrate_bps = static_cast<int>(flags::MaxBitrate()) * 1000;
   stream->max_bitrate_bps = static_cast<int>(flags::MaxBitrate()) * 1000;
   stream->max_framerate = 30;
   stream->max_qp = 56;
 
-  VideoSendStream* send_stream = call->CreateVideoSendStream(send_config);
+  VideoSendStream* send_stream =
+      call->CreateVideoSendStream(send_config, video_streams, NULL);
 
   Clock* test_clock = Clock::GetRealTimeClock();
 
diff --git a/webrtc/video/rampup_tests.cc b/webrtc/video/rampup_tests.cc
index c86963d..989deea 100644
--- a/webrtc/video/rampup_tests.cc
+++ b/webrtc/video/rampup_tests.cc
@@ -430,12 +430,15 @@
     receiver_transport.SetReceiver(call->Receiver());
 
     test::FakeEncoder encoder(Clock::GetRealTimeClock());
-    send_config.encoder_settings =
-        test::CreateEncoderSettings(&encoder, "FAKE", 125, num_streams);
+    send_config.encoder_settings.encoder = &encoder;
+    send_config.encoder_settings.payload_type = 125;
+    send_config.encoder_settings.payload_name = "FAKE";
+    std::vector<VideoStream> video_streams =
+        test::CreateVideoStreams(num_streams);
 
     if (num_streams == 1) {
-      send_config.encoder_settings.streams[0].target_bitrate_bps = 2000000;
-      send_config.encoder_settings.streams[0].max_bitrate_bps = 2000000;
+      video_streams[0].target_bitrate_bps = 2000000;
+      video_streams[0].max_bitrate_bps = 2000000;
     }
 
     send_config.pacing = pacing;
@@ -455,25 +458,22 @@
       // For multi stream rampup until all streams are being sent. That means
       // enough birate to sent all the target streams plus the min bitrate of
       // the last one.
-      int expected_bitrate_bps =
-          send_config.encoder_settings.streams.back().min_bitrate_bps;
-      for (size_t i = 0; i < send_config.encoder_settings.streams.size() - 1;
-           ++i) {
-        expected_bitrate_bps +=
-            send_config.encoder_settings.streams[i].target_bitrate_bps;
+      int expected_bitrate_bps = video_streams.back().min_bitrate_bps;
+      for (size_t i = 0; i < video_streams.size() - 1; ++i) {
+        expected_bitrate_bps += video_streams[i].target_bitrate_bps;
       }
       stream_observer.set_expected_bitrate_bps(expected_bitrate_bps);
     }
 
-    VideoSendStream* send_stream = call->CreateVideoSendStream(send_config);
+    VideoSendStream* send_stream =
+        call->CreateVideoSendStream(send_config, video_streams, NULL);
 
     scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
-        test::FrameGeneratorCapturer::Create(
-            send_stream->Input(),
-            send_config.encoder_settings.streams.back().width,
-            send_config.encoder_settings.streams.back().height,
-            send_config.encoder_settings.streams.back().max_framerate,
-            Clock::GetRealTimeClock()));
+        test::FrameGeneratorCapturer::Create(send_stream->Input(),
+                                             video_streams.back().width,
+                                             video_streams.back().height,
+                                             video_streams.back().max_framerate,
+                                             Clock::GetRealTimeClock()));
 
     send_stream->Start();
     frame_generator_capturer->Start();
@@ -504,23 +504,29 @@
     receiver_transport.SetReceiver(call->Receiver());
 
     test::FakeEncoder encoder(Clock::GetRealTimeClock());
-    send_config.encoder_settings =
-        test::CreateEncoderSettings(&encoder, "FAKE", 125, number_of_streams);
+    send_config.encoder_settings.encoder = &encoder;
+    send_config.encoder_settings.payload_type = 125;
+    send_config.encoder_settings.payload_name = "FAKE";
+    std::vector<VideoStream> video_streams =
+        test::CreateVideoStreams(number_of_streams);
+
     send_config.rtp.nack.rtp_history_ms = 1000;
     send_config.rtp.ssrcs.insert(
         send_config.rtp.ssrcs.begin(), ssrcs.begin(), ssrcs.end());
     send_config.rtp.extensions.push_back(
         RtpExtension(RtpExtension::kAbsSendTime, kAbsoluteSendTimeExtensionId));
     send_config.suspend_below_min_bitrate = true;
+    send_config.pacing = true;
 
-    VideoSendStream* send_stream = call->CreateVideoSendStream(send_config);
+    VideoSendStream* send_stream =
+        call->CreateVideoSendStream(send_config, video_streams, NULL);
     stream_observer.SetSendStream(send_stream);
 
     size_t width = 0;
     size_t height = 0;
-    for (size_t i = 0; i < send_config.encoder_settings.streams.size(); ++i) {
-      size_t stream_width = send_config.encoder_settings.streams[i].width;
-      size_t stream_height = send_config.encoder_settings.streams[i].height;
+    for (size_t i = 0; i < video_streams.size(); ++i) {
+      size_t stream_width = video_streams[i].width;
+      size_t stream_height = video_streams[i].height;
       if (stream_width > width)
         width = stream_width;
       if (stream_height > height)
diff --git a/webrtc/video/video_receive_stream.cc b/webrtc/video/video_receive_stream.cc
index 012ca68..9c3298c 100644
--- a/webrtc/video/video_receive_stream.cc
+++ b/webrtc/video/video_receive_stream.cc
@@ -150,13 +150,13 @@
 
   external_codec_ = ViEExternalCodec::GetInterface(video_engine);
   for (size_t i = 0; i < config_.external_decoders.size(); ++i) {
-    ExternalVideoDecoder* decoder = &config_.external_decoders[i];
+    const ExternalVideoDecoder& decoder = config_.external_decoders[i];
     if (external_codec_->RegisterExternalReceiveCodec(
             channel_,
-            decoder->payload_type,
-            decoder->decoder,
-            decoder->renderer,
-            decoder->expected_delay_ms) != 0) {
+            decoder.payload_type,
+            decoder.decoder,
+            decoder.renderer,
+            decoder.expected_delay_ms) != 0) {
       // TODO(pbos): Abort gracefully? Can this be a runtime error?
       abort();
     }
diff --git a/webrtc/video/video_receive_stream.h b/webrtc/video/video_receive_stream.h
index 4ff086a..2a3c6df 100644
--- a/webrtc/video/video_receive_stream.h
+++ b/webrtc/video/video_receive_stream.h
@@ -69,7 +69,7 @@
  private:
   TransportAdapter transport_adapter_;
   EncodedFrameCallbackAdapter encoded_frame_proxy_;
-  VideoReceiveStream::Config config_;
+  const VideoReceiveStream::Config config_;
   Clock* const clock_;
 
   ViEBase* video_engine_base_;
diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc
index 886e3dc..8a43387 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -15,6 +15,7 @@
 #include <vector>
 
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
+#include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/video_engine/include/vie_base.h"
 #include "webrtc/video_engine/include/vie_capture.h"
 #include "webrtc/video_engine/include/vie_codec.h"
@@ -32,18 +33,7 @@
   ss << "{payload_name: " << payload_name;
   ss << ", payload_type: " << payload_type;
   if (encoder != NULL)
-    ss << ", (encoder)";
-  if (encoder_settings != NULL)
-    ss << ", (encoder_settings)";
-
-  ss << ", streams: {";
-  for (size_t i = 0; i < streams.size(); ++i) {
-    ss << streams[i].ToString();
-    if (i != streams.size() - 1)
-      ss << "}, {";
-  }
-  ss << '}';
-
+    ss << ", encoder: " << (encoder != NULL ? "(encoder)" : "NULL");
   ss << '}';
   return ss.str();
 }
@@ -124,10 +114,11 @@
                                  CpuOveruseObserver* overuse_observer,
                                  webrtc::VideoEngine* video_engine,
                                  const VideoSendStream::Config& config,
+                                 const std::vector<VideoStream> video_streams,
+                                 const void* encoder_settings,
                                  int base_channel)
     : transport_adapter_(transport),
       encoded_frame_proxy_(config.post_encode_callback),
-      codec_lock_(CriticalSectionWrapper::CreateCriticalSection()),
       config_(config),
       external_codec_(NULL),
       channel_(-1),
@@ -141,7 +132,7 @@
 
   assert(config_.rtp.ssrcs.size() > 0);
   if (config_.suspend_below_min_bitrate)
-    config_.pacing = true;
+    assert(config_.pacing);
   rtp_rtcp_->SetTransmissionSmoothingStatus(channel_, config_.pacing);
 
   assert(config_.rtp.min_transmit_bitrate_bps >= 0);
@@ -216,10 +207,8 @@
   }
 
   codec_ = ViECodec::GetInterface(video_engine);
-  if (!ReconfigureVideoEncoder(config_.encoder_settings.streams,
-                               config_.encoder_settings.encoder_settings)) {
+  if (!ReconfigureVideoEncoder(video_streams, encoder_settings))
     abort();
-  }
 
   if (overuse_observer)
     video_engine_base_->RegisterCpuOveruseObserver(channel_, overuse_observer);
@@ -232,9 +221,8 @@
                                                     &encoded_frame_proxy_);
   }
 
-  if (config_.suspend_below_min_bitrate) {
+  if (config_.suspend_below_min_bitrate)
     codec_->SuspendBelowMinBitrate(channel_);
-  }
 
   rtp_rtcp_->RegisterSendChannelRtcpStatisticsCallback(channel_,
                                                        stats_proxy_.get());
@@ -304,15 +292,12 @@
 
 bool VideoSendStream::ReconfigureVideoEncoder(
     const std::vector<VideoStream>& streams,
-    void* encoder_settings) {
+    const void* encoder_settings) {
   assert(!streams.empty());
   assert(config_.rtp.ssrcs.size() >= streams.size());
   // TODO(pbos): Wire encoder_settings.
   assert(encoder_settings == NULL);
 
-  // VideoStreams in config_.encoder_settings need to be locked.
-  CriticalSectionScoped crit(codec_lock_.get());
-
   VideoCodec video_codec;
   memset(&video_codec, 0, sizeof(video_codec));
   video_codec.codecType =
@@ -383,8 +368,8 @@
   if (video_codec.startBitrate > video_codec.maxBitrate)
     video_codec.startBitrate = video_codec.maxBitrate;
 
-  assert(config_.encoder_settings.streams[0].max_framerate > 0);
-  video_codec.maxFramerate = config_.encoder_settings.streams[0].max_framerate;
+  assert(streams[0].max_framerate > 0);
+  video_codec.maxFramerate = streams[0].max_framerate;
 
   if (codec_->SetSendCodec(channel_, video_codec) != 0)
     return false;
@@ -396,9 +381,6 @@
                             static_cast<unsigned char>(i));
   }
 
-  config_.encoder_settings.streams = streams;
-  config_.encoder_settings.encoder_settings = encoder_settings;
-
   if (config_.rtp.rtx.ssrcs.empty())
     return true;
 
diff --git a/webrtc/video/video_send_stream.h b/webrtc/video/video_send_stream.h
index a7e2267..125c7fd 100644
--- a/webrtc/video/video_send_stream.h
+++ b/webrtc/video/video_send_stream.h
@@ -42,6 +42,8 @@
                   CpuOveruseObserver* overuse_observer,
                   webrtc::VideoEngine* video_engine,
                   const VideoSendStream::Config& config,
+                  const std::vector<VideoStream> video_streams,
+                  const void* encoder_settings,
                   int base_channel);
 
   virtual ~VideoSendStream();
@@ -50,7 +52,7 @@
   virtual void Stop() OVERRIDE;
 
   virtual bool ReconfigureVideoEncoder(const std::vector<VideoStream>& streams,
-                                       void* encoder_settings) OVERRIDE;
+                                       const void* encoder_settings) OVERRIDE;
 
   virtual Stats GetStats() const OVERRIDE;
 
@@ -70,8 +72,7 @@
  private:
   TransportAdapter transport_adapter_;
   EncodedFrameCallbackAdapter encoded_frame_proxy_;
-  scoped_ptr<CriticalSectionWrapper> codec_lock_;
-  VideoSendStream::Config config_;
+  const VideoSendStream::Config config_;
 
   ViEBase* video_engine_base_;
   ViECapture* capture_;
diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc
index 6662866..db71f54 100644
--- a/webrtc/video/video_send_stream_tests.cc
+++ b/webrtc/video/video_send_stream_tests.cc
@@ -45,9 +45,9 @@
 
  protected:
   void RunSendTest(Call* call,
-                   const VideoSendStream::Config& config,
                    test::RtpRtcpObserver* observer) {
-    send_stream_ = call->CreateVideoSendStream(config);
+    send_stream_ =
+        call->CreateVideoSendStream(send_config_, video_streams_, NULL);
     scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
         test::FrameGeneratorCapturer::Create(
             send_stream_->Input(), 320, 240, 30, Clock::GetRealTimeClock()));
@@ -62,17 +62,16 @@
     call->DestroyVideoSendStream(send_stream_);
   }
 
-  VideoSendStream::Config GetSendTestConfig(Call* call, size_t num_streams) {
+  void CreateTestConfig(Call* call, size_t num_streams) {
     assert(num_streams <= kNumSendSsrcs);
-    VideoSendStream::Config config = call->GetDefaultSendConfig();
-    config.encoder_settings = test::CreateEncoderSettings(
-        &fake_encoder_, "FAKE", kFakeSendPayloadType, num_streams);
-    config.encoder_settings.encoder = &fake_encoder_;
-    config.encoder_settings.payload_type = kFakeSendPayloadType;
+    send_config_ = call->GetDefaultSendConfig();
+    send_config_.encoder_settings.encoder = &fake_encoder_;
+    send_config_.encoder_settings.payload_name = "FAKE";
+    send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
+    video_streams_ = test::CreateVideoStreams(num_streams);
+    send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
     for (size_t i = 0; i < num_streams; ++i)
-      config.rtp.ssrcs.push_back(kSendSsrcs[i]);
-    config.pacing = true;
-    return config;
+      send_config_.rtp.ssrcs.push_back(kSendSsrcs[i]);
   }
 
   void TestNackRetransmission(uint32_t retransmit_ssrc,
@@ -91,6 +90,8 @@
   static const uint32_t kSendRtxSsrc;
   static const uint32_t kSendSsrcs[kNumSendSsrcs];
 
+  VideoSendStream::Config send_config_;
+  std::vector<VideoStream> video_streams_;
   VideoSendStream* send_stream_;
   test::FakeEncoder fake_encoder_;
 };
@@ -158,24 +159,23 @@
   Call::Config call_config(observer.SendTransport());
   scoped_ptr<Call> call(Call::Create(call_config));
 
-  VideoSendStream::Config send_config =
-      GetSendTestConfig(call.get(), num_ssrcs);
+  CreateTestConfig(call.get(), num_ssrcs);
 
   if (num_ssrcs > 1) {
     // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
-    std::vector<VideoStream>* streams = &send_config.encoder_settings.streams;
-    for (size_t i = 0; i < streams->size(); ++i) {
-      (*streams)[i].min_bitrate_bps = 10000;
-      (*streams)[i].target_bitrate_bps = 10000;
-      (*streams)[i].max_bitrate_bps = 10000;
+    for (size_t i = 0; i < video_streams_.size(); ++i) {
+      video_streams_[i].min_bitrate_bps = 10000;
+      video_streams_[i].target_bitrate_bps = 10000;
+      video_streams_[i].max_bitrate_bps = 10000;
     }
   }
 
-  std::vector<VideoStream> all_streams = send_config.encoder_settings.streams;
+  std::vector<VideoStream> all_streams = video_streams_;
   if (send_single_ssrc_first)
-    send_config.encoder_settings.streams.resize(1);
+    video_streams_.resize(1);
 
-  send_stream_ = call->CreateVideoSendStream(send_config);
+  send_stream_ =
+      call->CreateVideoSendStream(send_config_, video_streams_, NULL);
   scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
       test::FrameGeneratorCapturer::Create(
           send_stream_->Input(), 320, 240, 30, Clock::GetRealTimeClock()));
@@ -204,8 +204,9 @@
   Call::Config call_config(&transport);
   scoped_ptr<Call> call(Call::Create(call_config));
 
-  VideoSendStream::Config config = GetSendTestConfig(call.get(), 1);
-  VideoSendStream* stream = call->CreateVideoSendStream(config);
+  CreateTestConfig(call.get(), 1);
+  VideoSendStream* stream =
+      call->CreateVideoSendStream(send_config_, video_streams_, NULL);
   stream->Start();
   stream->Start();
   call->DestroyVideoSendStream(stream);
@@ -216,8 +217,9 @@
   Call::Config call_config(&transport);
   scoped_ptr<Call> call(Call::Create(call_config));
 
-  VideoSendStream::Config config = GetSendTestConfig(call.get(), 1);
-  VideoSendStream* stream = call->CreateVideoSendStream(config);
+  CreateTestConfig(call.get(), 1);
+  VideoSendStream* stream =
+      call->CreateVideoSendStream(send_config_, video_streams_, NULL);
   stream->Stop();
   stream->Stop();
   call->DestroyVideoSendStream(stream);
@@ -260,10 +262,10 @@
   Call::Config call_config(observer.SendTransport());
   scoped_ptr<Call> call(Call::Create(call_config));
 
-  VideoSendStream::Config send_config = GetSendTestConfig(call.get(), 1);
-  send_config.rtp.c_name = kCName;
+  CreateTestConfig(call.get(), 1);
+  send_config_.rtp.c_name = kCName;
 
-  RunSendTest(call.get(), send_config, &observer);
+  RunSendTest(call.get(), &observer);
 }
 
 TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
@@ -292,11 +294,11 @@
   Call::Config call_config(observer.SendTransport());
   scoped_ptr<Call> call(Call::Create(call_config));
 
-  VideoSendStream::Config send_config = GetSendTestConfig(call.get(), 1);
-  send_config.rtp.extensions.push_back(
+  CreateTestConfig(call.get(), 1);
+  send_config_.rtp.extensions.push_back(
       RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
 
-  RunSendTest(call.get(), send_config, &observer);
+  RunSendTest(call.get(), &observer);
 }
 
 TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
@@ -339,12 +341,12 @@
   Call::Config call_config(observer.SendTransport());
   scoped_ptr<Call> call(Call::Create(call_config));
 
-  VideoSendStream::Config send_config = GetSendTestConfig(call.get(), 1);
-  send_config.encoder_settings.encoder = &encoder;
-  send_config.rtp.extensions.push_back(
+  CreateTestConfig(call.get(), 1);
+  send_config_.encoder_settings.encoder = &encoder;
+  send_config_.rtp.extensions.push_back(
       RtpExtension(RtpExtension::kTOffset, kTOffsetExtensionId));
 
-  RunSendTest(call.get(), send_config, &observer);
+  RunSendTest(call.get(), &observer);
 }
 
 class FakeReceiveStatistics : public NullReceiveStatistics {
@@ -413,8 +415,9 @@
   Call::Config call_config(&transport);
   scoped_ptr<Call> call(Call::Create(call_config));
 
-  VideoSendStream::Config send_config = GetSendTestConfig(call.get(), 1);
-  VideoSendStream* video_send_stream = call->CreateVideoSendStream(send_config);
+  CreateTestConfig(call.get(), 1);
+  VideoSendStream* video_send_stream =
+      call->CreateVideoSendStream(send_config_, video_streams_, NULL);
   video_send_stream->Start();
 
   I420VideoFrame frame;
@@ -492,11 +495,11 @@
 
   observer.SetReceivers(call->Receiver(), NULL);
 
-  VideoSendStream::Config send_config = GetSendTestConfig(call.get(), 1);
-  send_config.rtp.fec.red_payload_type = kRedPayloadType;
-  send_config.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
+  CreateTestConfig(call.get(), 1);
+  send_config_.rtp.fec.red_payload_type = kRedPayloadType;
+  send_config_.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
 
-  RunSendTest(call.get(), send_config, &observer);
+  RunSendTest(call.get(), &observer);
 }
 
 void VideoSendStreamTest::TestNackRetransmission(
@@ -568,14 +571,14 @@
   scoped_ptr<Call> call(Call::Create(call_config));
   observer.SetReceivers(call->Receiver(), NULL);
 
-  VideoSendStream::Config send_config = GetSendTestConfig(call.get(), 1);
-  send_config.rtp.nack.rtp_history_ms = 1000;
-  send_config.rtp.rtx.payload_type = retransmit_payload_type;
-  send_config.pacing = enable_pacing;
+  CreateTestConfig(call.get(), 1);
+  send_config_.rtp.nack.rtp_history_ms = 1000;
+  send_config_.rtp.rtx.payload_type = retransmit_payload_type;
+  send_config_.pacing = enable_pacing;
   if (retransmit_ssrc != kSendSsrc)
-    send_config.rtp.rtx.ssrcs.push_back(retransmit_ssrc);
+    send_config_.rtp.rtx.ssrcs.push_back(retransmit_ssrc);
 
-  RunSendTest(call.get(), send_config, &observer);
+  RunSendTest(call.get(), &observer);
 }
 
 TEST_F(VideoSendStreamTest, RetransmitsNack) {
@@ -762,27 +765,27 @@
 
   observer.SetReceivers(call->Receiver(), NULL);
 
-  VideoSendStream::Config send_config = GetSendTestConfig(call.get(), 1);
+  CreateTestConfig(call.get(), 1);
   if (with_fec) {
-    send_config.rtp.fec.red_payload_type = kRedPayloadType;
-    send_config.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
+    send_config_.rtp.fec.red_payload_type = kRedPayloadType;
+    send_config_.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
   }
 
   if (format == kVP8)
-    send_config.encoder_settings.payload_name = "VP8";
+    send_config_.encoder_settings.payload_name = "VP8";
 
-  send_config.pacing = false;
-  send_config.encoder_settings.encoder = &encoder;
-  send_config.rtp.max_packet_size = kMaxPacketSize;
-  send_config.post_encode_callback = &observer;
+  send_config_.pacing = false;
+  send_config_.encoder_settings.encoder = &encoder;
+  send_config_.rtp.max_packet_size = kMaxPacketSize;
+  send_config_.post_encode_callback = &observer;
 
   // Add an extension header, to make the RTP header larger than the base
   // length of 12 bytes.
   static const uint8_t kAbsSendTimeExtensionId = 13;
-  send_config.rtp.extensions.push_back(
+  send_config_.rtp.extensions.push_back(
       RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
 
-  RunSendTest(call.get(), send_config, &observer);
+  RunSendTest(call.get(), &observer);
 }
 
 // TODO(sprang): Is there any way of speeding up these tests?
@@ -948,18 +951,19 @@
   scoped_ptr<Call> call(Call::Create(call_config));
   observer.SetReceiver(call->Receiver());
 
-  VideoSendStream::Config send_config = GetSendTestConfig(call.get(), 1);
-  send_config.rtp.nack.rtp_history_ms = 1000;
-  send_config.pre_encode_callback = &observer;
-  send_config.suspend_below_min_bitrate = true;
-  int min_bitrate_bps = send_config.encoder_settings.streams[0].min_bitrate_bps;
+  CreateTestConfig(call.get(), 1);
+  send_config_.rtp.nack.rtp_history_ms = 1000;
+  send_config_.pre_encode_callback = &observer;
+  send_config_.suspend_below_min_bitrate = true;
+  send_config_.pacing = true;
+  int min_bitrate_bps = video_streams_[0].min_bitrate_bps;
   observer.set_low_remb_bps(min_bitrate_bps - 10000);
   int threshold_window = std::max(min_bitrate_bps / 10, 10000);
-  ASSERT_GT(send_config.encoder_settings.streams[0].max_bitrate_bps,
+  ASSERT_GT(video_streams_[0].max_bitrate_bps,
             min_bitrate_bps + threshold_window + 5000);
   observer.set_high_remb_bps(min_bitrate_bps + threshold_window + 5000);
 
-  RunSendTest(call.get(), send_config, &observer);
+  RunSendTest(call.get(), &observer);
   observer.Stop();
 }
 
@@ -1022,9 +1026,10 @@
   scoped_ptr<Call> call(Call::Create(call_config));
   observer.SetReceivers(call->Receiver(), call->Receiver());
 
-  VideoSendStream::Config send_config = GetSendTestConfig(call.get(), 3);
+  CreateTestConfig(call.get(), 3);
 
-  send_stream_ = call->CreateVideoSendStream(send_config);
+  send_stream_ =
+      call->CreateVideoSendStream(send_config_, video_streams_, NULL);
   scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
       test::FrameGeneratorCapturer::Create(
           send_stream_->Input(), 320, 240, 30, Clock::GetRealTimeClock()));
@@ -1107,11 +1112,13 @@
   Call::Config call_config(observer.SendTransport());
   scoped_ptr<Call> call(Call::Create(call_config));
 
-  VideoSendStream::Config send_config = GetSendTestConfig(call.get(), 1);
-  send_config.rtp.c_name = kCName;
-  observer.SetConfig(send_config);
+  CreateTestConfig(call.get(), 1);
+  send_config_.rtp.c_name = kCName;
+  send_config_.pacing = true;
+  observer.SetConfig(send_config_);
 
-  send_stream_ = call->CreateVideoSendStream(send_config);
+  send_stream_ =
+      call->CreateVideoSendStream(send_config_, video_streams_, NULL);
   observer.SetSendStream(send_stream_);
   scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
       test::FrameGeneratorCapturer::Create(
@@ -1202,9 +1209,10 @@
   scoped_ptr<Call> call(Call::Create(call_config));
   observer.SetReceivers(&observer, call->Receiver());
 
-  VideoSendStream::Config send_config = GetSendTestConfig(call.get(), 1);
-  send_config.rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
-  send_stream_ = call->CreateVideoSendStream(send_config);
+  CreateTestConfig(call.get(), 1);
+  send_config_.rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
+  send_stream_ =
+      call->CreateVideoSendStream(send_config_, video_streams_, NULL);
   observer.SetSendStream(send_stream_);
 
   scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
diff --git a/webrtc/video_send_stream.h b/webrtc/video_send_stream.h
index e173e3b..b33f389 100644
--- a/webrtc/video_send_stream.h
+++ b/webrtc/video_send_stream.h
@@ -66,8 +66,7 @@
     std::string ToString() const;
 
     struct EncoderSettings {
-      EncoderSettings()
-          : payload_type(-1), encoder(NULL), encoder_settings(NULL) {}
+      EncoderSettings() : payload_type(-1), encoder(NULL) {}
       std::string ToString() const;
 
       std::string payload_name;
@@ -76,13 +75,6 @@
       // Uninitialized VideoEncoder instance to be used for encoding. Will be
       // initialized from inside the VideoSendStream.
       webrtc::VideoEncoder* encoder;
-      // TODO(pbos): Wire up encoder-specific settings.
-      // Encoder-specific settings, will be passed to the encoder during
-      // initialization.
-      void* encoder_settings;
-
-      // List of stream settings to encode (resolution, bitrates, framerate).
-      std::vector<VideoStream> streams;
     } encoder_settings;
 
     static const size_t kDefaultMaxPacketSize = 1500 - 40;  // TCP over IPv4.
@@ -155,8 +147,7 @@
     // True if the stream should be suspended when the available bitrate fall
     // below the minimum configured bitrate. If this variable is false, the
     // stream may send at a rate higher than the estimated available bitrate.
-    // Enabling suspend_below_min_bitrate will also enable pacing and padding,
-    // otherwise, the video will be unable to recover from suspension.
+    // |suspend_below_min_bitrate| requires |pacing| to be enabled as well.
     bool suspend_below_min_bitrate;
   };
 
@@ -171,7 +162,7 @@
   // in the config. Encoder settings are passed on to the encoder instance along
   // with the VideoStream settings.
   virtual bool ReconfigureVideoEncoder(const std::vector<VideoStream>& streams,
-                                       void* encoder_settings) = 0;
+                                       const void* encoder_settings) = 0;
 
   virtual Stats GetStats() const = 0;