Add PeerConnectionInterface::UpdateCallBitrate with call tests.

webrtc/pc/peerconnectioninterface_unittest.cc

 /*
  *  Copyright 2012 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 3279 matching lines @@
   std::unique_ptr<SessionDescriptionInterface> offer;
   ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
   EXPECT_TRUE(DoSetRemoteDescription(offer.release()));
 
   // Create and set answer as well.
   std::unique_ptr<SessionDescriptionInterface> answer;
   ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
   EXPECT_TRUE(DoSetLocalDescription(answer.release()));
 }
 
+TEST_F(PeerConnectionInterfaceTest, SetBitrateWithoutMinSucceeds) {
+  CreatePeerConnection();
+  PeerConnectionInterface::BitrateParameters bitrate;
+  bitrate.current_bitrate_bps = rtc::Optional<int>(100000);
+  EXPECT_TRUE(pc_->SetBitrate(bitrate).ok());
+}
+
+TEST_F(PeerConnectionInterfaceTest, SetBitrateNegativeMinFails) {
+  CreatePeerConnection();
+  PeerConnectionInterface::BitrateParameters bitrate;
+  bitrate.min_bitrate_bps = rtc::Optional<int>(-1);
+  EXPECT_FALSE(pc_->SetBitrate(bitrate).ok());
+}
+
+TEST_F(PeerConnectionInterfaceTest, SetBitrateCurrentLessThanMinFails) {
+  CreatePeerConnection();
+  PeerConnectionInterface::BitrateParameters bitrate;
+  bitrate.min_bitrate_bps = rtc::Optional<int>(5);
+  bitrate.current_bitrate_bps = rtc::Optional<int>(3);
+  EXPECT_FALSE(pc_->SetBitrate(bitrate).ok());
+}
+
+TEST_F(PeerConnectionInterfaceTest, SetBitrateCurrentNegativeFails) {
+  CreatePeerConnection();
+  PeerConnectionInterface::BitrateParameters bitrate;
+  bitrate.current_bitrate_bps = rtc::Optional<int>(-1);
+  EXPECT_FALSE(pc_->SetBitrate(bitrate).ok());
+}
+
+TEST_F(PeerConnectionInterfaceTest, SetBitrateMaxLessThanCurrentFails) {
+  CreatePeerConnection();
+  PeerConnectionInterface::BitrateParameters bitrate;
+  bitrate.current_bitrate_bps = rtc::Optional<int>(10);
+  bitrate.max_bitrate_bps = rtc::Optional<int>(8);
+  EXPECT_FALSE(pc_->SetBitrate(bitrate).ok());
+}
+
+TEST_F(PeerConnectionInterfaceTest, SetBitrateMaxLessThanMinFails) {
+  CreatePeerConnection();
+  PeerConnectionInterface::BitrateParameters bitrate;
+  bitrate.min_bitrate_bps = rtc::Optional<int>(10);
+  bitrate.max_bitrate_bps = rtc::Optional<int>(8);
+  EXPECT_FALSE(pc_->SetBitrate(bitrate).ok());
+}
+
+TEST_F(PeerConnectionInterfaceTest, SetBitrateMaxNegativeFails) {
+  CreatePeerConnection();
+  PeerConnectionInterface::BitrateParameters bitrate;
+  bitrate.max_bitrate_bps = rtc::Optional<int>(-1);
+  EXPECT_FALSE(pc_->SetBitrate(bitrate).ok());
+}
+
+// The current bitrate from Call's BitrateConfigMask is currently clamped by
+// Call's BitrateConfig, which comes from the SDP or a default value. This test
+// checks that a call to SetBitrate with a current bitrate that will be clamped
+// succeeds.
+TEST_F(PeerConnectionInterfaceTest, SetBitrateCurrentLessThanImplicitMin) {
+  CreatePeerConnection();
+  PeerConnectionInterface::BitrateParameters bitrate;
+  bitrate.current_bitrate_bps = rtc::Optional<int>(1);
+  EXPECT_TRUE(pc_->SetBitrate(bitrate).ok());
+}
+
 class PeerConnectionMediaConfigTest : public testing::Test {
  protected:
   void SetUp() override {
     pcf_ = new rtc::RefCountedObject<PeerConnectionFactoryForTest>();
     pcf_->Initialize();
   }
   const cricket::MediaConfig TestCreatePeerConnection(
       const PeerConnectionInterface::RTCConfiguration& config,
       const MediaConstraintsInterface *constraints) {
 
@@ skipping 272 matching lines @@
   EXPECT_NE(a, f);
 
   PeerConnectionInterface::RTCConfiguration g;
   g.disable_ipv6 = true;
   EXPECT_NE(a, g);
 
   PeerConnectionInterface::RTCConfiguration h(
       PeerConnectionInterface::RTCConfigurationType::kAggressive);
   EXPECT_NE(a, h);
 }