commit 725448760ec749e62f2a3843a491c278599d1963
author pbos@webrtc.org <pbos@webrtc.org@4adac7df-926f-26a2-2b94-8c16560cd09d> Fri Jun 06 10:49:19 2014 +0000
committer pbos@webrtc.org <pbos@webrtc.org@4adac7df-926f-26a2-2b94-8c16560cd09d> Fri Jun 06 10:49:19 2014 +0000
tree 04c69d66b8c91798ecb9d7af71de4eeca218c1db
parent 57a0606715062e7a5c605e05eaf9bf7b78e859d0

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/talk@6349 4adac7df-926f-26a2-2b94-8c16560cd09d

media/webrtc/webrtcvideoengine2_unittest.cc

diff --git a/media/webrtc/webrtcvideoengine2_unittest.cc b/media/webrtc/webrtcvideoengine2_unittest.cc
index bba1455..c478b42 100644
--- a/media/webrtc/webrtcvideoengine2_unittest.cc
+++ b/media/webrtc/webrtcvideoengine2_unittest.cc
@@ -52,12 +52,12 @@
 namespace cricket {
 class FakeVideoSendStream : public webrtc::VideoSendStream {
  public:
-  explicit FakeVideoSendStream(const webrtc::VideoSendStream::Config& config)
-      : sending_(false) {
-    config_ = config;
-  }
+  FakeVideoSendStream(const webrtc::VideoSendStream::Config& config,
+                      const std::vector<webrtc::VideoStream>& video_streams)
+      : sending_(false), config_(config), video_streams_(video_streams) {}
 
   webrtc::VideoSendStream::Config GetConfig() { return config_; }
+  std::vector<webrtc::VideoStream> GetVideoStreams() { return video_streams_; }
 
   bool IsSending() { return sending_; }
 
@@ -68,9 +68,8 @@
 
   virtual bool ReconfigureVideoEncoder(
       const std::vector<webrtc::VideoStream>& streams,
-      void* encoder_specific) OVERRIDE {
-    // TODO(pbos): Store encoder_specific ptr?
-    config_.encoder_settings.streams = streams;
+      const void* encoder_specific) OVERRIDE {
+    video_streams_ = streams;
     return true;
   }
 
@@ -85,6 +84,7 @@
 
   bool sending_;
   webrtc::VideoSendStream::Config config_;
+  std::vector<webrtc::VideoStream> video_streams_;
 };
 
 class FakeVideoReceiveStream : public webrtc::VideoReceiveStream {
@@ -178,8 +178,11 @@
   }
 
   virtual webrtc::VideoSendStream* CreateVideoSendStream(
-      const webrtc::VideoSendStream::Config& config) OVERRIDE {
-    FakeVideoSendStream* fake_stream = new FakeVideoSendStream(config);
+      const webrtc::VideoSendStream::Config& config,
+      const std::vector<webrtc::VideoStream>& video_streams,
+      const void* encoder_settings) OVERRIDE {
+    FakeVideoSendStream* fake_stream =
+        new FakeVideoSendStream(config, video_streams);
     video_send_streams_.push_back(fake_stream);
     return fake_stream;
   }
@@ -515,13 +518,10 @@
 
     FakeVideoSendStream* stream = AddSendStream();
 
-    webrtc::VideoSendStream::Config::EncoderSettings encoder_settings =
-        stream->GetConfig().encoder_settings;
-    ASSERT_EQ(1u, encoder_settings.streams.size());
-    EXPECT_EQ(atoi(min_bitrate),
-              encoder_settings.streams.back().min_bitrate_bps / 1000);
-    EXPECT_EQ(atoi(max_bitrate),
-              encoder_settings.streams.back().max_bitrate_bps / 1000);
+    std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
+    ASSERT_EQ(1u, video_streams.size());
+    EXPECT_EQ(atoi(min_bitrate), video_streams.back().min_bitrate_bps / 1000);
+    EXPECT_EQ(atoi(max_bitrate), video_streams.back().max_bitrate_bps / 1000);
 
     VideoCodec codec;
     EXPECT_TRUE(channel_->GetSendCodec(&codec));
@@ -556,15 +556,14 @@
   const unsigned int kVideoTargetSendBitrateKbps = 300;
   const unsigned int kVideoMaxSendBitrateKbps = 2000;
   FakeVideoSendStream* stream = AddSendStream();
-  webrtc::VideoSendStream::Config::EncoderSettings encoder_settings =
-      stream->GetConfig().encoder_settings;
-  ASSERT_EQ(1u, encoder_settings.streams.size());
+  std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
+  ASSERT_EQ(1u, video_streams.size());
   EXPECT_EQ(kVideoMinSendBitrateKbps,
-            encoder_settings.streams.back().min_bitrate_bps / 1000);
+            video_streams.back().min_bitrate_bps / 1000);
   EXPECT_EQ(kVideoTargetSendBitrateKbps,
-            encoder_settings.streams.back().target_bitrate_bps / 1000);
+            video_streams.back().target_bitrate_bps / 1000);
   EXPECT_EQ(kVideoMaxSendBitrateKbps,
-            encoder_settings.streams.back().max_bitrate_bps / 1000);
+            video_streams.back().max_bitrate_bps / 1000);
 #if 0
   // TODO(pbos): un-#if
   VerifyVP8SendCodec(send_channel, kVP8Codec.width, kVP8Codec.height, 0,
@@ -925,9 +924,8 @@
   codecs.push_back(kVp8Codec);
   codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
   EXPECT_TRUE(channel_->SetSendCodecs(codecs));
-  EXPECT_EQ(
-      static_cast<unsigned int>(atoi(kMaxQuantization)),
-      AddSendStream()->GetConfig().encoder_settings.streams.back().max_qp);
+  EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)),
+            AddSendStream()->GetVideoStreams().back().max_qp);
 
   VideoCodec codec;
   EXPECT_TRUE(channel_->GetSendCodec(&codec));