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

webrtc/media/engine/webrtcvoiceengine_unittest.cc

 /*
  *  Copyright (c) 2008 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 171 matching lines @@
     EXPECT_EQ(2, telephone_event.event_code);
     EXPECT_EQ(123, telephone_event.duration_ms);
   }
 
   // Test that send bandwidth is set correctly.
   // |codec| is the codec under test.
   // |max_bitrate| is a parameter to set to SetMaxSendBandwidth().
   // |expected_result| is the expected result from SetMaxSendBandwidth().
   // |expected_bitrate| is the expected audio bitrate afterward.
   void TestSendBandwidth(const cricket::AudioCodec& codec,
-                         int max_bitrate,
+                         rtc::Optional<int> max_bitrate,
                          bool expected_result,
                          int expected_bitrate) {
     cricket::AudioSendParameters parameters;
     parameters.codecs.push_back(codec);
-    parameters.max_bandwidth_bps = max_bitrate;
+    parameters.max_bitrate_bps = max_bitrate;
     EXPECT_EQ(expected_result, channel_->SetSendParameters(parameters));
 
     int channel_num = voe_.GetLastChannel();
     webrtc::CodecInst temp_codec;
     EXPECT_FALSE(voe_.GetSendCodec(channel_num, temp_codec));
     EXPECT_EQ(expected_bitrate, temp_codec.rate);
   }
 
   void TestSetSendRtpHeaderExtensions(const std::string& ext) {
     EXPECT_TRUE(SetupEngineWithSendStream());
@@ skipping 478 matching lines @@
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) {
   EXPECT_TRUE(SetupEngineWithSendStream());
 
   // Test that when autobw is enabled, bitrate is kept as the default
   // value. autobw is enabled for the following tests because the target
   // bitrate is <= 0.
 
   // ISAC, default bitrate == 32000.
-  TestSendBandwidth(kIsacCodec, 0, true, 32000);
+  TestSendBandwidth(kIsacCodec, rtc::Optional<int>(), true, 32000);
 
   // PCMU, default bitrate == 64000.
-  TestSendBandwidth(kPcmuCodec, -1, true, 64000);
+  TestSendBandwidth(kPcmuCodec, rtc::Optional<int>(), true, 64000);
 
   // opus, default bitrate == 64000.
-  TestSendBandwidth(kOpusCodec, -1, true, 64000);
+  TestSendBandwidth(kOpusCodec, rtc::Optional<int>(), true, 64000);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) {
   EXPECT_TRUE(SetupEngineWithSendStream());
 
   // Test that the bitrate of a multi-rate codec is always the maximum.
 
   // ISAC, default bitrate == 32000.
-  TestSendBandwidth(kIsacCodec, 128000, true, 128000);
-  TestSendBandwidth(kIsacCodec, 16000, true, 16000);
+  TestSendBandwidth(kIsacCodec, rtc::Optional<int>(128000), true, 128000);
+  TestSendBandwidth(kIsacCodec, rtc::Optional<int>(16000), true, 16000);
 
   // opus, default bitrate == 64000.
-  TestSendBandwidth(kOpusCodec, 96000, true, 96000);
-  TestSendBandwidth(kOpusCodec, 48000, true, 48000);
+  TestSendBandwidth(kOpusCodec, rtc::Optional<int>(96000), true, 96000);
+  TestSendBandwidth(kOpusCodec, rtc::Optional<int>(48000), true, 48000);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) {
   EXPECT_TRUE(SetupEngineWithSendStream());
 
   // Test that we can only set a maximum bitrate for a fixed-rate codec
   // if it's bigger than the fixed rate.
 
   // PCMU, fixed bitrate == 64000.
-  TestSendBandwidth(kPcmuCodec, 0, true, 64000);
-  TestSendBandwidth(kPcmuCodec, 1, false, 64000);
-  TestSendBandwidth(kPcmuCodec, 128000, true, 64000);
-  TestSendBandwidth(kPcmuCodec, 32000, false, 64000);
-  TestSendBandwidth(kPcmuCodec, 64000, true, 64000);
-  TestSendBandwidth(kPcmuCodec, 63999, false, 64000);
-  TestSendBandwidth(kPcmuCodec, 64001, true, 64000);
+  TestSendBandwidth(kPcmuCodec, rtc::Optional<int>(), true, 64000);
+  TestSendBandwidth(kPcmuCodec, rtc::Optional<int>(1), false, 64000);
+  TestSendBandwidth(kPcmuCodec, rtc::Optional<int>(128000), true, 64000);
+  TestSendBandwidth(kPcmuCodec, rtc::Optional<int>(32000), false, 64000);
+  TestSendBandwidth(kPcmuCodec, rtc::Optional<int>(64000), true, 64000);
+  TestSendBandwidth(kPcmuCodec, rtc::Optional<int>(63999), false, 64000);
+  TestSendBandwidth(kPcmuCodec, rtc::Optional<int>(64001), true, 64000);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) {
   EXPECT_TRUE(SetupEngine());
   const int kDesiredBitrate = 128000;
   cricket::AudioSendParameters parameters;
   parameters.codecs = engine_.codecs();
-  parameters.max_bandwidth_bps = kDesiredBitrate;
+  parameters.max_bitrate_bps = rtc::Optional<int>(kDesiredBitrate);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
   EXPECT_TRUE(channel_->AddSendStream(
       cricket::StreamParams::CreateLegacy(kSsrc1)));
 
   int channel_num = voe_.GetLastChannel();
   webrtc::CodecInst codec;
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
   EXPECT_EQ(kDesiredBitrate, codec.rate);
 }
 
 // Test that bitrate cannot be set for CBR codecs.
 // Bitrate is ignored if it is higher than the fixed bitrate.
 // Bitrate less then the fixed bitrate is an error.
 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) {
   EXPECT_TRUE(SetupEngineWithSendStream());
 
   // PCMU, default bitrate == 64000.
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   int channel_num = voe_.GetLastChannel();
   webrtc::CodecInst codec;
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
   EXPECT_EQ(64000, codec.rate);
 
-  send_parameters_.max_bandwidth_bps = 128000;
+  send_parameters_.max_bitrate_bps = rtc::Optional<int>(128000);
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
   EXPECT_EQ(64000, codec.rate);
 
-  send_parameters_.max_bandwidth_bps = 128;
+  send_parameters_.max_bitrate_bps = rtc::Optional<int>(128);
   EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
   EXPECT_EQ(64000, codec.rate);
 }
 
 // Test that we apply codecs properly.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) {
   EXPECT_TRUE(SetupEngineWithSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
@@ skipping 2568 matching lines @@
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   std::unique_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
   cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::MediaConfig(),
                                            cricket::AudioOptions(), call.get());
   cricket::AudioRecvParameters parameters;
   parameters.codecs = engine.codecs();
   EXPECT_TRUE(channel.SetRecvParameters(parameters));
 }