Enable setting the maximum bitrate limit in RtpSender.

webrtc/pc/channel_unittest.cc

 /*
  *  Copyright 2009 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 1749 matching lines @@
     TransportChannel* rtp = channel1_->transport_channel();
     EXPECT_FALSE(media_channel1_->ready_to_send());
     // In the case of rtcp mux, the SignalReadyToSend() from rtp channel
     // should trigger the MediaChannel's OnReadyToSend.
     rtp->SignalReadyToSend(rtp);
     EXPECT_TRUE(media_channel1_->ready_to_send());
     channel1_->SetReadyToSend(false, false);
     EXPECT_FALSE(media_channel1_->ready_to_send());
   }
 
+  bool SetRemoteContentWithBitrateLimit(int remote_limit) {
+    typename T::Content content;
+    CreateContent(0, kPcmuCodec, kH264Codec, &content);
+    content.set_bandwidth(remote_limit);
+    return channel1_->SetRemoteContent(&content, CA_OFFER, NULL);
+  }
+
+  webrtc::RTCRtpParameters BitrateLimitedParameters(int limit) {
+    webrtc::RTCRtpParameters parameters;
+    webrtc::RTCRtpEncodingParameters encoding;
+    encoding.max_bitrate_bps = limit;
+    parameters.encodings.push_back(encoding);
+    return parameters;
+  }
+
+  void VerifyMaxBitrate(const webrtc::RTCRtpParameters& parameters,
+                        int expected_bitrate) {
+    EXPECT_EQ(1UL, parameters.encodings.size());
+    EXPECT_EQ(expected_bitrate, parameters.encodings[0].max_bitrate_bps);
+  }
+
+  void DefaultMaxBitrateIsUnlimited() {
+    CreateChannels(0, 0);
+    EXPECT_EQ(media_channel1_->max_bps(), -1);
+    VerifyMaxBitrate(media_channel1_->GetRtpParameters(kSsrc1), -1);
+  }
+
+  void CanChangeMaxBitrate() {
+    CreateChannels(0, 0);
+
+    EXPECT_TRUE(
+        channel1_->SetRtpParameters(kSsrc1, BitrateLimitedParameters(1000)));
+    VerifyMaxBitrate(channel1_->GetRtpParameters(kSsrc1), 1000);
+    VerifyMaxBitrate(media_channel1_->GetRtpParameters(kSsrc1), 1000);
+    EXPECT_EQ(-1, media_channel1_->max_bps());
+
+    EXPECT_TRUE(
+        channel1_->SetRtpParameters(kSsrc1, BitrateLimitedParameters(-1)));
+    VerifyMaxBitrate(channel1_->GetRtpParameters(kSsrc1), -1);
+    VerifyMaxBitrate(media_channel1_->GetRtpParameters(kSsrc1), -1);
+    EXPECT_EQ(-1, media_channel1_->max_bps());
+  }

[Taylor Brandstetter, 2016/03/12 01:57:06]

Very thorough unit tests, I'm impressed. :)

+
  protected:
   // TODO(pbos): Remove playout from all media channels and let renderers mute
   // themselves.
   const bool verify_playout_;
   cricket::FakeTransportController transport_controller1_;
   cricket::FakeTransportController transport_controller2_;
   cricket::FakeMediaEngine media_engine_;
   // The media channels are owned by the voice channel objects below.
   typename T::MediaChannel* media_channel1_;
   typename T::MediaChannel* media_channel2_;
@@ skipping 440 matching lines @@
 }
 
 TEST_F(VoiceChannelTest, SendBundleToBundleWithRtcpMux) {
   Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), true, false);
 }
 
 TEST_F(VoiceChannelTest, SendBundleToBundleWithRtcpMuxSecure) {
   Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), true, true);
 }
 
+TEST_F(VoiceChannelTest, DefaultMaxBitrateIsUnlimited) {
+  Base::DefaultMaxBitrateIsUnlimited();
+}
+
+TEST_F(VoiceChannelTest, CanChangeMaxBitrate) {
+  Base::CanChangeMaxBitrate();
+}
+
 // VideoChannelTest
 TEST_F(VideoChannelTest, TestInit) {
   Base::TestInit();
 }
 
 TEST_F(VideoChannelTest, TestSetContents) {
   Base::TestSetContents();
 }
 
 TEST_F(VideoChannelTest, TestSetContentsNullOffer) {
@@ skipping 238 matching lines @@
 }
 
 TEST_F(VideoChannelTest, TestOnReadyToSend) {
   Base::TestOnReadyToSend();
 }
 
 TEST_F(VideoChannelTest, TestOnReadyToSendWithRtcpMux) {
   Base::TestOnReadyToSendWithRtcpMux();
 }
 
+TEST_F(VideoChannelTest, DefaultMaxBitrateIsUnlimited) {
+  Base::DefaultMaxBitrateIsUnlimited();
+}
+
+TEST_F(VideoChannelTest, CanChangeMaxBitrate) {
+  Base::CanChangeMaxBitrate();
+}
+
 // DataChannelTest
 
 class DataChannelTest
     : public ChannelTest<DataTraits> {
  public:
   typedef ChannelTest<DataTraits>
   Base;
   DataChannelTest()
       : Base(true,
              kDataPacket,
@@ skipping 192 matching lines @@
   };
   rtc::Buffer payload(data, 3);
   cricket::SendDataResult result;
   ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
   EXPECT_EQ(params.ssrc,
             media_channel1_->last_sent_data_params().ssrc);
   EXPECT_EQ("foo", media_channel1_->last_sent_data());
 }
 
 // TODO(pthatcher): TestSetReceiver?