Add PeerConnectionInterface::UpdateCallBitrate with call tests.

webrtc/call/call_unittest.cc

 /*
  *  Copyright (c) 2015 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.
  */
 
 #include <list>
 #include <map>
 #include <memory>
+#include <utility>
 
+#include "webrtc/base/ptr_util.h"
 #include "webrtc/call/audio_state.h"
 #include "webrtc/call/call.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/modules/audio_mixer/audio_mixer_impl.h"
+#include "webrtc/modules/congestion_controller/include/send_side_congestion_controller.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/mock_audio_decoder_factory.h"
 #include "webrtc/test/mock_transport.h"
 #include "webrtc/test/mock_voice_engine.h"
 
 namespace {
 
 struct CallHelper {
   explicit CallHelper(
       rtc::scoped_refptr<webrtc::AudioDecoderFactory> decoder_factory = nullptr)
@@ skipping 269 matching lines @@
   config.remote_ssrc = 5548;
   stream = call->CreateFlexfecReceiveStream(config);
   EXPECT_NE(stream, nullptr);
   streams.push_back(stream);
 
   for (auto s : streams) {
     call->DestroyFlexfecReceiveStream(s);
   }
 }
 
+// TODO(zstein): This probably belongs in webrtc/modules/congestion_controller/
+class MockSendSideCongestionController : public SendSideCongestionController {
+ public:
+  MockSendSideCongestionController(const Clock* clock,
+                                   Observer* observer,
+                                   RtcEventLog* event_log,
+                                   PacketRouter* packet_router)
+      : SendSideCongestionController(clock,
+                                     observer,
+                                     event_log,
+                                     packet_router) {}
+
+  MOCK_METHOD3(SetBweBitrates, void(int, int, int));
+};
+
+class FakeRtpTransportController : public RtpTransportControllerSendInterface {
+ public:
+  explicit FakeRtpTransportController(PacketRouter* r,
+                                      SendSideCongestionController* cc)
+      : packet_router_(r), send_side_cc_(cc) {}
+
+  PacketRouter* packet_router() override { return packet_router_; }
+
+  SendSideCongestionController* send_side_cc() override {
+    return send_side_cc_;
+  }
+
+  TransportFeedbackObserver* transport_feedback_observer() override {
+    return send_side_cc_;
+  }
+
+  RtpPacketSender* packet_sender() override { return nullptr; }
+
+ private:
+  PacketRouter* packet_router_;
+  SendSideCongestionController* send_side_cc_;
+};
+
+class CallBitrateTest : public testing::Test {
+ public:
+  void SetUp() {
+    Clock* clock = Clock::GetRealTimeClock();  // TODO(zstein): test clock?
+    mock_cc_ =
+        rtc::MakeUnique<testing::NiceMock<MockSendSideCongestionController>>(
+            clock, nullptr, &event_log_, &packet_router_);
+  }
+
+  void CreateCall() {
+    Call::Config config(&event_log_);
+    CreateCall(config);
+  }
+
+  void CreateCall(const Call::Config& config) {
+    std::unique_ptr<RtpTransportControllerSendInterface> fake_controller =
+        rtc::MakeUnique<FakeRtpTransportController>(&packet_router_,
+                                                    mock_cc_.get());
+    call_.reset(Call::Create(config, std::move(fake_controller)));
+  }
+
+  std::unique_ptr<testing::NiceMock<MockSendSideCongestionController>> mock_cc_;
+  std::unique_ptr<Call> call_;
+
+  webrtc::RtcEventLogNullImpl event_log_;
+
+ private:
+  PacketRouter packet_router_;  // TODO(zstein): fake?
+};
+
+using testing::_;
+
+TEST_F(CallBitrateTest, MinMaskPreferred) {
+  CreateCall();
+  Call::Config::BitrateConfigMask mask;
+  mask.min_bitrate_bps = rtc::Optional<int>(1234);
+
+  EXPECT_CALL(*mock_cc_, SetBweBitrates(*mask.min_bitrate_bps, _, _));
+  EXPECT_TRUE(call_->SetBitrateConfigMask(mask).ok());
+}
+
+TEST_F(CallBitrateTest, StartMaskPreferred) {
+  CreateCall();
+  Call::Config::BitrateConfigMask mask;
+  mask.start_bitrate_bps = rtc::Optional<int>(1234);
+
+  EXPECT_CALL(*mock_cc_, SetBweBitrates(_, *mask.start_bitrate_bps, _));
+  EXPECT_TRUE(call_->SetBitrateConfigMask(mask).ok());
+}
+
+TEST_F(CallBitrateTest, SmallerMaskMaxUsed) {
+  Call::Config config(&event_log_);
+  config.bitrate_config.max_bitrate_bps =
+      config.bitrate_config.start_bitrate_bps + 2000;
+  CreateCall(config);
+
+  Call::Config::BitrateConfigMask mask;
+  mask.max_bitrate_bps =
+      rtc::Optional<int>(config.bitrate_config.start_bitrate_bps + 1000);
+
+  EXPECT_CALL(*mock_cc_, SetBweBitrates(_, _, *mask.max_bitrate_bps));
+  EXPECT_TRUE(call_->SetBitrateConfigMask(mask).ok());
+}
+
+TEST_F(CallBitrateTest, SmallerConfigMaxUsed) {
+  Call::Config config(&event_log_);
+  config.bitrate_config.max_bitrate_bps =
+      config.bitrate_config.start_bitrate_bps + 1000;
+  CreateCall(config);
+
+  Call::Config::BitrateConfigMask mask;
+  mask.max_bitrate_bps =
+      rtc::Optional<int>(config.bitrate_config.start_bitrate_bps + 2000);
+
+  // Expect no calls because nothing changes
+  EXPECT_CALL(*mock_cc_, SetBweBitrates(_, _, _)).Times(0);
+  EXPECT_TRUE(call_->SetBitrateConfigMask(mask).ok());
+}
+
+TEST_F(CallBitrateTest, MaskStartLessThanConfigMinFails) {
+  Call::Config config(&event_log_);
+  config.bitrate_config.min_bitrate_bps = 2000;
+  CreateCall(config);
+
+  Call::Config::BitrateConfigMask mask;
+  mask.start_bitrate_bps = rtc::Optional<int>(1000);
+
+  EXPECT_FALSE(call_->SetBitrateConfigMask(mask).ok());
+}
+
+TEST_F(CallBitrateTest, MaskMaxLessThanConfigStartFails) {
+  Call::Config config(&event_log_);
+  config.bitrate_config.start_bitrate_bps = 2000;
+  CreateCall(config);
+
+  Call::Config::BitrateConfigMask mask;
+  mask.max_bitrate_bps = rtc::Optional<int>(1000);
+
+  EXPECT_FALSE(call_->SetBitrateConfigMask(mask).ok());
+}
+
+TEST_F(CallBitrateTest, MaskMaxLessThanConfigMinFails) {
+  Call::Config config(&event_log_);
+  config.bitrate_config.min_bitrate_bps = 2000;
+  CreateCall(config);
+
+  Call::Config::BitrateConfigMask mask;
+  mask.max_bitrate_bps = rtc::Optional<int>(1000);
+
+  EXPECT_FALSE(call_->SetBitrateConfigMask(mask).ok());
+}
+
+TEST_F(CallBitrateTest, SettingStartForcesUpdate) {
+  CreateCall();
+
+  Call::Config::BitrateConfigMask mask;
+  mask.start_bitrate_bps = rtc::Optional<int>(1000);
+
+  // SetBweBitrates should be called twice with the same params when
+  // start_bitrate_bps is set.
+  EXPECT_CALL(*mock_cc_, SetBweBitrates(_, 1000, _)).Times(2);
+  EXPECT_TRUE(call_->SetBitrateConfigMask(mask).ok());
+  EXPECT_TRUE(call_->SetBitrateConfigMask(mask).ok());
+}
+
+// TODO(zstein): Delete or rename.
+TEST_F(CallBitrateTest, TaylorCR) {
+  CreateCall();
+
+  Call::Config::BitrateConfig config1;
+  config1.min_bitrate_bps = 0;
+  config1.start_bitrate_bps = 1000;
+  config1.max_bitrate_bps = -1;
+
+  Call::Config::BitrateConfig config2;
+  config2.min_bitrate_bps = 0;
+  config2.start_bitrate_bps = -1;
+  config2.max_bitrate_bps = -1;
+
+  EXPECT_CALL(*mock_cc_, SetBweBitrates(0, 1000, -1));
+  call_->SetBitrateConfig(config1);
+  call_->SetBitrateConfig(config2);
+}
+

[Taylor Brandstetter, 2017/05/05 08:04:32]

I have some other suggestions for tests. Can you take a look here:

https://codereview.webrtc.org/2862653004/diff2/1:20001/webrtc/call/call_unitt...

[Zach Stein, 2017/05/09 00:41:26]

Thanks, these are great test cases. Did you have these passing with the clamped
version of the code? They don't pass for me (but I might have messed up a merge
somewhere).

[Taylor Brandstetter, 2017/05/09 15:51:54]

One is passing, but two aren't. The issue is that an old
"start_bitrate"/"current_bitrate" ends up being passed into SetBweBitrates if
SetBitrateConfig[Mask] is called with an unset/-1 value.

 }  // namespace webrtc