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

webrtc/pc/mediasession_unittest.cc

 /*
  *  Copyright 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 41 matching lines @@
 using cricket::CryptoParamsVec;
 using cricket::AudioContentDescription;
 using cricket::VideoContentDescription;
 using cricket::DataContentDescription;
 using cricket::GetFirstAudioContent;
 using cricket::GetFirstVideoContent;
 using cricket::GetFirstDataContent;
 using cricket::GetFirstAudioContentDescription;
 using cricket::GetFirstVideoContentDescription;
 using cricket::GetFirstDataContentDescription;
-using cricket::kAutoBandwidth;
 using cricket::AudioCodec;
 using cricket::VideoCodec;
 using cricket::DataCodec;
 using cricket::NS_JINGLE_RTP;
 using cricket::MEDIA_TYPE_AUDIO;
 using cricket::MEDIA_TYPE_VIDEO;
 using cricket::MEDIA_TYPE_DATA;
 using cricket::RtpHeaderExtension;
 using cricket::SEC_DISABLED;
 using cricket::SEC_ENABLED;
@@ skipping 397 matching lines @@
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* vc = offer->GetContentByName("video");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc == NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
-  EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
+  EXPECT_EQ(rtc::Optional<int>(),
+            acd->bandwidth());                  // default bandwidth (auto)
   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
 }
 
 // Create a typical video offer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoOffer) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   f1_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* vc = offer->GetContentByName("video");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
-  EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
+  EXPECT_EQ(rtc::Optional<int>(),
+            acd->bandwidth());                  // default bandwidth (auto)
   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
   EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
   EXPECT_EQ(f1_.video_codecs(), vcd->codecs());
   EXPECT_NE(0U, vcd->first_ssrc());             // a random nonzero ssrc
-  EXPECT_EQ(kAutoBandwidth, vcd->bandwidth());  // default bandwidth (auto)
+  EXPECT_EQ(rtc::Optional<int>(),
+            vcd->bandwidth());                  // default bandwidth (auto)
   EXPECT_TRUE(vcd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
 }
 
 // Test creating an offer with bundle where the Codecs have the same dynamic
 // RTP playlod type. The test verifies that the offer don't contain the
 // duplicate RTP payload types.
 TEST_F(MediaSessionDescriptionFactoryTest, TestBundleOfferWithSameCodecPlType) {
   const VideoCodec& offered_video_codec = f2_.video_codecs()[0];
@@ skipping 79 matching lines @@
   ASSERT_TRUE(dc != NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), dc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const DataContentDescription* dcd =
       static_cast<const DataContentDescription*>(dc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
-  EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
+  EXPECT_EQ(rtc::Optional<int>(),
+            acd->bandwidth());                  // default bandwidth (auto)
   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
   EXPECT_EQ(MEDIA_TYPE_DATA, dcd->type());
   EXPECT_EQ(f1_.data_codecs(), dcd->codecs());
   EXPECT_NE(0U, dcd->first_ssrc());             // a random nonzero ssrc
+  EXPECT_TRUE(dcd->bandwidth());
   EXPECT_EQ(cricket::kDataMaxBandwidth,
-            dcd->bandwidth());                  // default bandwidth (auto)
+            *dcd->bandwidth());                 // default bandwidth (auto)
   EXPECT_TRUE(dcd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), dcd->protocol());
 }
 
 // Create an SCTP data offer with bundle without error.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSctpDataOffer) {
   MediaSessionOptions opts;
   opts.recv_audio = false;
   opts.bundle_enabled = true;
@@ skipping 121 matching lines @@
       f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc == NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
-  EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
-  EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
-  EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
+  EXPECT_NE(0U, acd->first_ssrc());                   // a random nonzero ssrc
+  EXPECT_EQ(rtc::Optional<int>(), acd->bandwidth());  // negotiated auto bw
+  EXPECT_TRUE(acd->rtcp_mux());                       // negotiated rtcp-mux
   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
 }
 
 // Create a typical video answer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswer) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
-  EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
-  EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
-  EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
+  EXPECT_EQ(rtc::Optional<int>(), acd->bandwidth());  // negotiated auto bw
+  EXPECT_NE(0U, acd->first_ssrc());                   // a random nonzero ssrc
+  EXPECT_TRUE(acd->rtcp_mux());                       // negotiated rtcp-mux
   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
   EXPECT_EQ(MAKE_VECTOR(kVideoCodecsAnswer), vcd->codecs());
   EXPECT_NE(0U, vcd->first_ssrc());             // a random nonzero ssrc
   EXPECT_TRUE(vcd->rtcp_mux());                 // negotiated rtcp-mux
   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateDataAnswer) {
@@ skipping 10 matching lines @@
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const DataContentDescription* vcd =
       static_cast<const DataContentDescription*>(vc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
-  EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
-  EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
-  EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
+  EXPECT_EQ(rtc::Optional<int>(), acd->bandwidth());  // negotiated auto bw
+  EXPECT_NE(0U, acd->first_ssrc());                   // a random nonzero ssrc
+  EXPECT_TRUE(acd->rtcp_mux());                       // negotiated rtcp-mux
   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(MEDIA_TYPE_DATA, vcd->type());
   EXPECT_EQ(MAKE_VECTOR(kDataCodecsAnswer), vcd->codecs());
   EXPECT_NE(0U, vcd->first_ssrc());             // a random nonzero ssrc
   EXPECT_TRUE(vcd->rtcp_mux());                 // negotiated rtcp-mux
   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
 }
 
 // Verifies that the order of the media contents in the offer is preserved in
@@ skipping 387 matching lines @@
   const StreamParamsVec& audio_streams = acd->streams();
   ASSERT_EQ(2U, audio_streams.size());
   EXPECT_EQ(audio_streams[0].cname , audio_streams[1].cname);
   EXPECT_EQ(kAudioTrack1, audio_streams[0].id);
   ASSERT_EQ(1U, audio_streams[0].ssrcs.size());
   EXPECT_NE(0U, audio_streams[0].ssrcs[0]);
   EXPECT_EQ(kAudioTrack2, audio_streams[1].id);
   ASSERT_EQ(1U, audio_streams[1].ssrcs.size());
   EXPECT_NE(0U, audio_streams[1].ssrcs[0]);
 
-  EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
+  EXPECT_EQ(rtc::Optional<int>(),
+            acd->bandwidth());                  // default bandwidth (auto)
   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
 
   EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
   EXPECT_EQ(f1_.video_codecs(), vcd->codecs());
   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
 
   const StreamParamsVec& video_streams = vcd->streams();
   ASSERT_EQ(1U, video_streams.size());
   EXPECT_EQ(video_streams[0].cname, audio_streams[0].cname);
   EXPECT_EQ(kVideoTrack1, video_streams[0].id);
-  EXPECT_EQ(kAutoBandwidth, vcd->bandwidth());  // default bandwidth (auto)
+  EXPECT_EQ(rtc::Optional<int>(),
+            vcd->bandwidth());                  // default bandwidth (auto)
   EXPECT_TRUE(vcd->rtcp_mux());                 // rtcp-mux defaults on
 
   EXPECT_EQ(MEDIA_TYPE_DATA, dcd->type());
   EXPECT_EQ(f1_.data_codecs(), dcd->codecs());
   ASSERT_CRYPTO(dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
 
   const StreamParamsVec& data_streams = dcd->streams();
   ASSERT_EQ(2U, data_streams.size());
   EXPECT_EQ(data_streams[0].cname , data_streams[1].cname);
   EXPECT_EQ(kDataTrack1, data_streams[0].id);
   ASSERT_EQ(1U, data_streams[0].ssrcs.size());
   EXPECT_NE(0U, data_streams[0].ssrcs[0]);
   EXPECT_EQ(kDataTrack2, data_streams[1].id);
   ASSERT_EQ(1U, data_streams[1].ssrcs.size());
   EXPECT_NE(0U, data_streams[1].ssrcs[0]);
 
+  EXPECT_TRUE(dcd->bandwidth());
   EXPECT_EQ(cricket::kDataMaxBandwidth,
-            dcd->bandwidth());                  // default bandwidth (auto)
+            *dcd->bandwidth());                 // default bandwidth (auto)
   EXPECT_TRUE(dcd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
 
 
   // Update the offer. Add a new video track that is not synched to the
   // other tracks and replace audio track 2 with audio track 3.
   opts.AddSendStream(MEDIA_TYPE_VIDEO, kVideoTrack2, kMediaStream2);
   opts.RemoveSendStream(MEDIA_TYPE_AUDIO, kAudioTrack2);
   opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack3, kMediaStream1);
   opts.RemoveSendStream(MEDIA_TYPE_DATA, kDataTrack2);
@@ skipping 121 matching lines @@
   const StreamParamsVec& audio_streams = acd->streams();
   ASSERT_EQ(2U, audio_streams.size());
   EXPECT_TRUE(audio_streams[0].cname ==  audio_streams[1].cname);
   EXPECT_EQ(kAudioTrack1, audio_streams[0].id);
   ASSERT_EQ(1U, audio_streams[0].ssrcs.size());
   EXPECT_NE(0U, audio_streams[0].ssrcs[0]);
   EXPECT_EQ(kAudioTrack2, audio_streams[1].id);
   ASSERT_EQ(1U, audio_streams[1].ssrcs.size());
   EXPECT_NE(0U, audio_streams[1].ssrcs[0]);
 
-  EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
+  EXPECT_EQ(rtc::Optional<int>(),
+            acd->bandwidth());                  // default bandwidth (auto)
   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
 
   EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
   EXPECT_EQ(MAKE_VECTOR(kVideoCodecsAnswer), vcd->codecs());
 
   const StreamParamsVec& video_streams = vcd->streams();
   ASSERT_EQ(1U, video_streams.size());
   EXPECT_EQ(video_streams[0].cname, audio_streams[0].cname);
   EXPECT_EQ(kVideoTrack1, video_streams[0].id);
-  EXPECT_EQ(kAutoBandwidth, vcd->bandwidth());  // default bandwidth (auto)
-  EXPECT_TRUE(vcd->rtcp_mux());                 // rtcp-mux defaults on
+  EXPECT_EQ(rtc::Optional<int>(), vcd->bandwidth());  // default bandwidth
+  EXPECT_TRUE(vcd->rtcp_mux());                       // rtcp-mux defaults on
 
   EXPECT_EQ(MEDIA_TYPE_DATA, dcd->type());
   EXPECT_EQ(MAKE_VECTOR(kDataCodecsAnswer), dcd->codecs());
 
   const StreamParamsVec& data_streams = dcd->streams();
   ASSERT_EQ(2U, data_streams.size());
   EXPECT_TRUE(data_streams[0].cname ==  data_streams[1].cname);
   EXPECT_EQ(kDataTrack1, data_streams[0].id);
   ASSERT_EQ(1U, data_streams[0].ssrcs.size());
   EXPECT_NE(0U, data_streams[0].ssrcs[0]);
   EXPECT_EQ(kDataTrack2, data_streams[1].id);
   ASSERT_EQ(1U, data_streams[1].ssrcs.size());
   EXPECT_NE(0U, data_streams[1].ssrcs[0]);
 
+  EXPECT_TRUE(dcd->bandwidth());
   EXPECT_EQ(cricket::kDataMaxBandwidth,
-            dcd->bandwidth());                  // default bandwidth (auto)
-  EXPECT_TRUE(dcd->rtcp_mux());                 // rtcp-mux defaults on
+            *dcd->bandwidth());  // default bandwidth (auto)
+  EXPECT_TRUE(dcd->rtcp_mux());  // rtcp-mux defaults on
 
   // Update the answer. Add a new video track that is not synched to the
   // other traacks and remove 1 audio track.
   opts.AddSendStream(MEDIA_TYPE_VIDEO, kVideoTrack2, kMediaStream2);
   opts.RemoveSendStream(MEDIA_TYPE_AUDIO, kAudioTrack2);
   opts.RemoveSendStream(MEDIA_TYPE_DATA, kDataTrack2);
   std::unique_ptr<SessionDescription> updated_answer(
       f2_.CreateAnswer(offer.get(), opts, answer.get()));
 
   ASSERT_TRUE(updated_answer.get() != NULL);
@@ skipping 938 matching lines @@
   const ContentInfo* audio_content = GetFirstAudioContent(updated_offer.get());
   const ContentInfo* video_content = GetFirstVideoContent(updated_offer.get());
   const ContentInfo* data_content = GetFirstDataContent(updated_offer.get());
   ASSERT_TRUE(audio_content != nullptr);
   ASSERT_TRUE(video_content != nullptr);
   ASSERT_TRUE(data_content != nullptr);
   EXPECT_EQ("audio_modified", audio_content->name);
   EXPECT_EQ("video_modified", video_content->name);
   EXPECT_EQ("data_modified", data_content->name);
 }