Support removing b=AS bandwidth constraints.

webrtc/media/engine/webrtcvideoengine2_unittest.cc

 /*
  *  Copyright (c) 2004 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 1060 matching lines @@
     std::vector<FakeVideoReceiveStream*> streams =
         fake_call_->GetVideoReceiveStreams();
     EXPECT_EQ(num_streams + 1, streams.size());
     return streams[streams.size() - 1];
   }
 
   void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps,
                                           int expected_min_bitrate_bps,
                                           const char* start_bitrate_kbps,
                                           int expected_start_bitrate_bps,
-                                          const char* max_bitrate_kbps,
-                                          int expected_max_bitrate_bps) {
+                                          const char* max_bitrate_kbps) {
     auto& codecs = send_parameters_.codecs;
     codecs.clear();
     codecs.push_back(GetEngineCodec("VP8"));
     codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps;
     codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps;
     codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps;
     EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
     EXPECT_EQ(expected_min_bitrate_bps,
               fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
     EXPECT_EQ(expected_start_bitrate_bps,
               fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
-    EXPECT_EQ(expected_max_bitrate_bps,
-              fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
+    // TODO(pbos): Consider checking stream bitrates. Codec bitrate does
+    // intentionally not affect global max bitrate.
   }
 
   void TestSetSendRtpHeaderExtensions(const std::string& ext_uri) {
     // Enable extension.
     const int id = 1;
     cricket::VideoSendParameters parameters = send_parameters_;
     parameters.extensions.push_back(RtpExtension(ext_uri, id));
     EXPECT_TRUE(channel_->SetSendParameters(parameters));
     FakeVideoSendStream* send_stream =
         AddSendStream(cricket::StreamParams::CreateLegacy(123));
@@ skipping 1533 matching lines @@
   parameters.codecs.clear();
   codec.SetParam(kCodecParamMaxQuantization, kDefaultQpMax + 1);
   parameters.codecs.push_back(codec);
   ASSERT_TRUE(channel_->SetSendParameters(parameters));
   streams = fake_call_->GetVideoSendStreams()[0]->GetVideoStreams();
   EXPECT_EQ(kDefaultQpMax + 1, streams[0].max_qp);
   EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithBitrates) {
-  SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
-                                     200000);
+  SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200");
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithHighMaxBitrate) {
-  SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000);
+  SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000");
   std::vector<webrtc::VideoStream> streams = AddSendStream()->GetVideoStreams();
   ASSERT_EQ(1u, streams.size());
   EXPECT_EQ(10000000, streams[0].max_bitrate_bps);
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        SetSendCodecsWithoutBitratesUsesCorrectDefaults) {
-  SetSendCodecsShouldWorkForBitrates(
-      "", 0, "", -1, "", -1);
+  SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "");
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsCapsMinAndStartBitrate) {
-  SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "", -1);
+  SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "");
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectsMaxLessThanMinBitrate) {
   send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "300";
   send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "200";
   EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
 }
 
 // Test that when both the codec-specific bitrate params and max_bandwidth_bps
 // are present in the same send parameters, the settings are combined correctly.
@@ skipping 27 matching lines @@
   // If we change the codec max, max_bandwidth_bps should still apply.
   send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "350";
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
   EXPECT_EQ(200000, fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
   EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        SetMaxSendBandwidthShouldPreserveOtherBitrates) {
-  SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
-                                     200000);
+  SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200");
   send_parameters_.max_bandwidth_bps = 300000;
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps)
       << "Setting max bitrate should keep previous min bitrate.";
   EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.start_bitrate_bps)
       << "Setting max bitrate should not reset start bitrate.";
   EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetMaxSendBandwidthShouldBeRemovable) {
   send_parameters_.max_bandwidth_bps = 300000;
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
-  // <= 0 means disable (infinite) max bitrate.
-  send_parameters_.max_bandwidth_bps = 0;
+  // -1 means disable (infinite) max bitrate.
+  send_parameters_.max_bandwidth_bps = -1;
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.max_bitrate_bps)
       << "Setting zero max bitrate did not reset start bitrate.";
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetMaxSendBandwidthAndAddSendStream) {
   send_parameters_.max_bandwidth_bps = 99999;
   FakeVideoSendStream* stream = AddSendStream();
   ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_EQ(send_parameters_.max_bandwidth_bps,
@@ skipping 1117 matching lines @@
   capturer.CaptureFrame();
 
   int default_encoder_bitrate = GetMaxEncoderBitrate();
   EXPECT_GT(default_encoder_bitrate, 1000);
 
   // TODO(skvlad): Resolve the inconsistency between the interpretation
   // of the global bitrate limit for audio and video:
   // - Audio: max_bandwidth_bps = 0 - fail the operation,
   //          max_bandwidth_bps = -1 - remove the bandwidth limit
   // - Video: max_bandwidth_bps = 0 - remove the bandwidth limit,
-  //          max_bandwidth_bps = -1 - do not change the previously set
-  //                                   limit.
+  //          max_bandwidth_bps = -1 - remove the bandwidth limit

[Taylor Brandstetter, 2017/03/09 23:48:38]

Hey, one inconsistency fixed. :)

 
   SetAndExpectMaxBitrate(1000, 0, 1000);
   SetAndExpectMaxBitrate(1000, 800, 800);
   SetAndExpectMaxBitrate(600, 800, 600);
   SetAndExpectMaxBitrate(0, 800, 800);
   SetAndExpectMaxBitrate(0, 0, default_encoder_bitrate);
 
   EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
 }
 
@@ skipping 473 matching lines @@
 }
 
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsForSimulcastScreenshare) {
   webrtc::test::ScopedFieldTrials override_field_trials_(
       "WebRTC-SimulcastScreenshare/Enabled/");
   VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 2, true,
                           true);
 }
 
 }  // namespace cricket