Reland of Fixes a bug where a video stream can get stuck in the suspended state.

webrtc/call/bitrate_allocator_unittest.cc

 /*
  *  Copyright (c) 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 80 matching lines @@
   allocator_->OnNetworkChanged(4000000, 0, 0, kDefaultProbingIntervalMs);
   EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
 
   // Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated.
   EXPECT_CALL(limit_observer_,
               OnAllocationLimitsChanged(kMinSendBitrateBps, 0));
   allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0,
                           true);
   EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer));
 
-  EXPECT_CALL(limit_observer_,
-              OnAllocationLimitsChanged(kMinSendBitrateBps, 0));
   allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, 0,
                           true);
   EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
   EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_);
   allocator_->OnNetworkChanged(1500000, 0, 0, kDefaultProbingIntervalMs);
   EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_);
 }
 
 TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
   TestBitrateObserver bitrate_observer_1;
@@ skipping 63 matching lines @@
   NiceMock<MockLimitObserver> limit_observer_;
   std::unique_ptr<BitrateAllocator> allocator_;
 };
 
 // The following three tests verify enforcing a minimum bitrate works as
 // intended.
 TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) {
   TestBitrateObserver bitrate_observer_1;
   // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since
   // AddObserver is called with |enforce_min_bitrate| = false.
-  EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0));
+  EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 120000));
   allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
 
   // High BWE.
   allocator_->OnNetworkChanged(150000, 0, 0, kDefaultProbingIntervalMs);
   EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_bps_);
 
   // Low BWE.
   allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs);
   EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
@@ skipping 60 matching lines @@
 
   allocator_->RemoveObserver(&bitrate_observer_1);
   allocator_->RemoveObserver(&bitrate_observer_2);
   allocator_->RemoveObserver(&bitrate_observer_3);
 }
 
 TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) {
   TestBitrateObserver bitrate_observer;
   // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since
   // AddObserver is called with |enforce_min_bitrate| = false.
-  EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0));
+  EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 168000));
   allocator_->AddObserver(
       &bitrate_observer, 100000, 400000, 0, false);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
 
   // High BWE.
   allocator_->OnNetworkChanged(150000, 0, 0, kDefaultProbingIntervalMs);
   EXPECT_EQ(150000u, bitrate_observer.last_bitrate_bps_);
 
   // Add loss and use a part of the bitrate for protection.
   double protection_ratio = 0.4;
   uint8_t fraction_loss = protection_ratio * 256;
   bitrate_observer.SetBitrateProtectionRatio(protection_ratio);
   allocator_->OnNetworkChanged(200000, 0, fraction_loss,
                                kDefaultProbingIntervalMs);
   EXPECT_EQ(200000u, bitrate_observer.last_bitrate_bps_);
 
   // Above the min threshold, but not enough given the protection used.
   allocator_->OnNetworkChanged(139000, 0, fraction_loss,
                                kDefaultProbingIntervalMs);
   EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);
 
   // Verify the hysteresis is added for the protection.
   allocator_->OnNetworkChanged(150000, 0, fraction_loss,
                                kDefaultProbingIntervalMs);
   EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);
 
   // Just enough to enable video again.
+  EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0));
   allocator_->OnNetworkChanged(168000, 0, fraction_loss,
                                kDefaultProbingIntervalMs);
   EXPECT_EQ(168000u, bitrate_observer.last_bitrate_bps_);
 
   // Remove all protection and make sure video is not paused as earlier.
   bitrate_observer.SetBitrateProtectionRatio(0.0);
   allocator_->OnNetworkChanged(140000, 0, 0, kDefaultProbingIntervalMs);
   EXPECT_EQ(140000u, bitrate_observer.last_bitrate_bps_);
 
   allocator_->OnNetworkChanged(139000, 0, 0, kDefaultProbingIntervalMs);
   EXPECT_EQ(139000u, bitrate_observer.last_bitrate_bps_);
 
-  EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0));
   allocator_->RemoveObserver(&bitrate_observer);
 }
 
 TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) {
   TestBitrateObserver bitrate_observer_1;
   TestBitrateObserver bitrate_observer_2;
 
   allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
   allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false);
@@ skipping 197 matching lines @@
   allocator_->AddObserver(&observer, 300000, 600000, 0, false);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
 
   allocator_->OnNetworkChanged(300000, 0, 50, 5000);
   EXPECT_EQ(5000, observer.last_probing_interval_ms_);
 
   allocator_->RemoveObserver(&observer);
 }
 
 }  // namespace webrtc