Updated structures and functions for setting the max bitrate limit to take rtc::Optional<int>

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 901 matching lines @@
 
   FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
     size_t num_streams = fake_call_->GetVideoReceiveStreams().size();
     EXPECT_TRUE(channel_->AddRecvStream(sp));
     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) {
+  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,
+      rtc::Optional<int> expected_max_bitrate_bps) {
     auto& codecs = send_parameters_.codecs;
     codecs.clear();
     codecs.push_back(kVp8Codec);
     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);
@@ skipping 149 matching lines @@
         fake_call_->GetVideoSendStreams();
     EXPECT_TRUE(streams.size() > 0);
     FakeVideoSendStream* stream = streams[streams.size() - 1];
 
     webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig();
     EXPECT_EQ(1, encoder_config.streams.size());
     return encoder_config.streams[0].max_bitrate_bps;
   }
 
   void SetAndExpectMaxBitrate(cricket::FakeVideoCapturer& capturer,
-                              int global_max,
-                              int stream_max,
+                              rtc::Optional<int> global_max,
+                              rtc::Optional<int> stream_max,
                               int expected_encoder_bitrate) {
     VideoSendParameters limited_send_params = send_parameters_;
-    limited_send_params.max_bandwidth_bps = global_max;
+    limited_send_params.max_bitrate_bps = global_max;
     EXPECT_TRUE(channel_->SetSendParameters(limited_send_params));
     webrtc::RtpParameters parameters = channel_->GetRtpParameters(last_ssrc_);
     EXPECT_EQ(1UL, parameters.encodings.size());
     parameters.encodings[0].max_bitrate_bps = stream_max;
     EXPECT_TRUE(channel_->SetRtpParameters(last_ssrc_, parameters));
     // Read back the parameteres and verify they have the correct value
     parameters = channel_->GetRtpParameters(last_ssrc_);
     EXPECT_EQ(1UL, parameters.encodings.size());
     EXPECT_EQ(stream_max, parameters.encodings[0].max_bitrate_bps);
     // Verify that the new value propagated down to the encoder
@@ skipping 1074 matching lines @@
   parameters.codecs.push_back(kVp8Codec360p);
   ASSERT_TRUE(channel_->SetSendParameters(parameters));
   streams = fake_call_->GetVideoSendStreams()[0]->GetVideoStreams();
   EXPECT_EQ(kVp8Codec360p.width, streams[0].width);
   EXPECT_EQ(kVp8Codec360p.height, streams[0].height);
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithBitrates) {
   SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
-                                     200000);
+                                     rtc::Optional<int>(200000));
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithHighMaxBitrate) {
-  SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000);
+  SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000",
+                                     rtc::Optional<int>(10000000));
   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, "", rtc::Optional<int>());
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsCapsMinAndStartBitrate) {
-  SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "", -1);
+  SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "",
+                                     rtc::Optional<int>());
 }
 
 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_F(WebRtcVideoChannel2Test,
        SetMaxSendBandwidthShouldPreserveOtherBitrates) {
   SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
-                                     200000);
-  send_parameters_.max_bandwidth_bps = 300000;
+                                     rtc::Optional<int>(200000));
+  send_parameters_.max_bitrate_bps = rtc::Optional<int>(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);
+  EXPECT_EQ(rtc::Optional<int>(300000),
+            fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetMaxSendBandwidthShouldBeRemovable) {
-  send_parameters_.max_bandwidth_bps = 300000;
+  send_parameters_.max_bitrate_bps = rtc::Optional<int>(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;
+  EXPECT_EQ(rtc::Optional<int>(300000),
+            fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
+  // <not set> means disable (infinite) max bitrate.
+  send_parameters_.max_bitrate_bps = rtc::Optional<int>();
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
-  EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.max_bitrate_bps)
+  EXPECT_EQ(rtc::Optional<int>(),
+            fake_call_->GetConfig().bitrate_config.max_bitrate_bps)
       << "Setting zero max bitrate did not reset start bitrate.";
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) {
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(kVp8Codec720p);
   ASSERT_TRUE(channel_->SetSendParameters(parameters));
   channel_->SetSend(true);
 
   FakeVideoSendStream* stream = AddSendStream();
 
   cricket::FakeVideoCapturer capturer;
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
 
   std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
   int initial_max_bitrate_bps = streams[0].max_bitrate_bps;
   EXPECT_GT(initial_max_bitrate_bps, 0);
 
-  parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
+  parameters.max_bitrate_bps = rtc::Optional<int>(initial_max_bitrate_bps * 2);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
   // Insert a frame to update the encoder config.
   EXPECT_TRUE(capturer.CaptureFrame());
   streams = stream->GetVideoStreams();
   EXPECT_EQ(initial_max_bitrate_bps * 2, streams[0].max_bitrate_bps);
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, nullptr));
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) {
@@ skipping 11 matching lines @@
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
   EXPECT_TRUE(capturer.CaptureFrame());
 
   std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
   ASSERT_GT(streams.size(), 1u)
       << "Without simulcast this test doesn't make sense.";
   int initial_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
   EXPECT_GT(initial_max_bitrate_bps, 0);
 
-  parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
+  parameters.max_bitrate_bps = rtc::Optional<int>(initial_max_bitrate_bps * 2);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
   // Insert a frame to update the encoder config.
   EXPECT_TRUE(capturer.CaptureFrame());
   streams = stream->GetVideoStreams();
   int increased_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
   EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps);
 
   EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], nullptr));
 }
 
@@ skipping 832 matching lines @@
 }
 
 TEST_F(WebRtcVideoChannel2Test, UlpfecPacketDoesntCreateUnsignalledStream) {
   TestReceiveUnsignalledSsrcPacket(kDefaultUlpfecType, false);
 }
 
 TEST_F(WebRtcVideoChannel2Test, RedRtxPacketDoesntCreateUnsignalledStream) {
   TestReceiveUnsignalledSsrcPacket(kRedRtxPayloadType, false);
 }
 
-TEST_F(WebRtcVideoChannel2Test, CanSentMaxBitrateForExistingStream) {
+TEST_F(WebRtcVideoChannel2Test, CanSetMaxBitrateForExistingStream) {
   AddSendStream();
 
   cricket::FakeVideoCapturer capturer;
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   cricket::VideoFormat capture_format_hd =
       capturer.GetSupportedFormats()->front();
   EXPECT_EQ(1280, capture_format_hd.width);
   EXPECT_EQ(720, capture_format_hd.height);
   EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
   EXPECT_TRUE(channel_->SetSend(true));
 
   int default_encoder_bitrate = GetMaxEncoderBitrate(capturer);
   EXPECT_TRUE(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.
-
-  SetAndExpectMaxBitrate(capturer, 1000, 0, 1000);
-  SetAndExpectMaxBitrate(capturer, 1000, 800, 800);
-  SetAndExpectMaxBitrate(capturer, 600, 800, 600);
-  SetAndExpectMaxBitrate(capturer, 0, 800, 800);
-  SetAndExpectMaxBitrate(capturer, 0, 0, default_encoder_bitrate);
+  SetAndExpectMaxBitrate(capturer, rtc::Optional<int>(1000),
+                         rtc::Optional<int>(), 1000);
+  SetAndExpectMaxBitrate(capturer, rtc::Optional<int>(1000),
+                         rtc::Optional<int>(800), 800);
+  SetAndExpectMaxBitrate(capturer, rtc::Optional<int>(600),
+                         rtc::Optional<int>(800), 600);
+  SetAndExpectMaxBitrate(capturer, rtc::Optional<int>(),
+                         rtc::Optional<int>(800), 800);
+  SetAndExpectMaxBitrate(capturer, rtc::Optional<int>(), rtc::Optional<int>(),
+                         default_encoder_bitrate);
 
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
 }
 
+TEST_F(WebRtcVideoChannel2Test, CannotSetNegativeOrZeroMaxBitrate) {
+  AddSendStream();
+  webrtc::RtpParameters bad_parameters;
+  bad_parameters.encodings.push_back(webrtc::RtpEncodingParameters());
+
+  bad_parameters.encodings[0].max_bitrate_bps = rtc::Optional<int>(0);
+  EXPECT_FALSE(channel_->SetRtpParameters(last_ssrc_, bad_parameters));
+  bad_parameters.encodings[0].max_bitrate_bps = rtc::Optional<int>(-1);
+  EXPECT_FALSE(channel_->SetRtpParameters(last_ssrc_, bad_parameters));
+}
+
 TEST_F(WebRtcVideoChannel2Test, CannotSetMaxBitrateForNonexistentStream) {
   webrtc::RtpParameters nonexistent_parameters =
       channel_->GetRtpParameters(last_ssrc_);
   EXPECT_EQ(0, nonexistent_parameters.encodings.size());
 
   nonexistent_parameters.encodings.push_back(webrtc::RtpEncodingParameters());
   EXPECT_FALSE(channel_->SetRtpParameters(last_ssrc_, nonexistent_parameters));
 }
 
 TEST_F(WebRtcVideoChannel2Test,
@@ skipping 100 matching lines @@
                                        codec.width, codec.height,
                                        cricket::VideoFormat::FpsToInterval(30),
                                        cricket::FOURCC_I420)));
     channel_->SetSend(true);
     EXPECT_TRUE(capturer.CaptureFrame());
 
     std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
     ASSERT_EQ(expected_num_streams, video_streams.size());
 
     std::vector<webrtc::VideoStream> expected_streams = GetSimulcastConfig(
-        num_configured_streams, codec.width, codec.height, 0, kDefaultQpMax,
+        num_configured_streams, codec.width, codec.height, rtc::Optional<int>(),
+        kDefaultQpMax,
         codec.framerate != 0 ? codec.framerate : kDefaultFramerate);
 
     ASSERT_EQ(expected_streams.size(), video_streams.size());
 
     size_t num_streams = video_streams.size();
     int total_max_bitrate_bps = 0;
     for (size_t i = 0; i < num_streams; ++i) {
       EXPECT_EQ(expected_streams[i].width, video_streams[i].width);
       EXPECT_EQ(expected_streams[i].height, video_streams[i].height);
 
@@ skipping 81 matching lines @@
 }
 
 // Test that we normalize send codec format size in simulcast.
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
   cricket::VideoCodec codec(kVp8Codec270p);
   codec.width += 1;
   codec.height += 1;
   VerifySimulcastSettings(codec, 2, 2);
 }
 }  // namespace cricket