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

webrtc/call/bitrate_allocator.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.
  *
  */
@@ skipping 36 matching lines @@
 
 BitrateAllocator::BitrateAllocator(LimitObserver* limit_observer)
     : limit_observer_(limit_observer),
       bitrate_observer_configs_(),
       last_bitrate_bps_(0),
       last_non_zero_bitrate_bps_(kDefaultBitrateBps),
       last_fraction_loss_(0),
       last_rtt_(0),
       num_pause_events_(0),
       clock_(Clock::GetRealTimeClock()),
-      last_bwe_log_time_(0) {
+      last_bwe_log_time_(0),
+      total_requested_padding_bitrate_(0),
+      total_requested_min_bitrate_(0) {
   sequenced_checker_.Detach();
 }
 
 BitrateAllocator::~BitrateAllocator() {
   RTC_HISTOGRAM_COUNTS_100("WebRTC.Call.NumberOfPauseEvents",
                            num_pause_events_);
 }
 
 void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps,
                                         uint8_t fraction_loss,
@@ skipping 40 matching lines @@
                    << ", configured min bitrate " << config.min_bitrate_bps
                    << ", current allocation " << allocated_bitrate
                    << " and protection bitrate " << protection_bitrate;
     }
 
     // Only update the media ratio if the observer got an allocation.
     if (allocated_bitrate > 0)
       config.media_ratio = MediaRatio(allocated_bitrate, protection_bitrate);
     config.allocated_bitrate_bps = allocated_bitrate;
   }
+  UpdateAllocationLimits();
 }
 
 void BitrateAllocator::AddObserver(BitrateAllocatorObserver* observer,
                                    uint32_t min_bitrate_bps,
                                    uint32_t max_bitrate_bps,
                                    uint32_t pad_up_bitrate_bps,
                                    bool enforce_min_bitrate) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
   auto it = FindObserverConfig(observer);
 
@@ skipping 32 matching lines @@
   }
   UpdateAllocationLimits();
 }
 
 void BitrateAllocator::UpdateAllocationLimits() {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
   uint32_t total_requested_padding_bitrate = 0;
   uint32_t total_requested_min_bitrate = 0;
 
   for (const auto& config : bitrate_observer_configs_) {
+    uint32_t stream_padding = config.pad_up_bitrate_bps;
     if (config.enforce_min_bitrate) {
       total_requested_min_bitrate += config.min_bitrate_bps;
+    } else if (config.allocated_bitrate_bps == 0) {
+      stream_padding =
+          std::max(MinBitrateWithHysteresis(config), stream_padding);
     }
-    total_requested_padding_bitrate += config.pad_up_bitrate_bps;
+    total_requested_padding_bitrate += stream_padding;
   }
 
+  if (total_requested_padding_bitrate == total_requested_padding_bitrate_ &&
+      total_requested_min_bitrate == total_requested_min_bitrate_) {
+    return;
+  }
+
+  total_requested_min_bitrate_ = total_requested_min_bitrate;
+  total_requested_padding_bitrate_ = total_requested_padding_bitrate;
+
   LOG(LS_INFO) << "UpdateAllocationLimits : total_requested_min_bitrate: "
                << total_requested_min_bitrate
                << "bps, total_requested_padding_bitrate: "
                << total_requested_padding_bitrate << "bps";
   limit_observer_->OnAllocationLimitsChanged(total_requested_min_bitrate,
                                              total_requested_padding_bitrate);
 }
 
 void BitrateAllocator::RemoveObserver(BitrateAllocatorObserver* observer) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
@@ skipping 223 matching lines @@
                                                     uint32_t sum_min_bitrates) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
   if (bitrate < sum_min_bitrates)
     return false;
 
   uint32_t extra_bitrate_per_observer =
       (bitrate - sum_min_bitrates) /
       static_cast<uint32_t>(bitrate_observer_configs_.size());
   for (const auto& observer_config : bitrate_observer_configs_) {
     if (observer_config.min_bitrate_bps + extra_bitrate_per_observer <
-        MinBitrateWithHysteresis(observer_config))
+        MinBitrateWithHysteresis(observer_config)) {
       return false;
+    }
   }
   return true;
 }
 }  // namespace webrtc