Simplify BitrateAllocator::AddBitrateObserver.

webrtc/modules/bitrate_controller/bitrate_allocator.cc

Index: webrtc/modules/bitrate_controller/bitrate_allocator.cc
diff --git a/webrtc/modules/bitrate_controller/bitrate_allocator.cc b/webrtc/modules/bitrate_controller/bitrate_allocator.cc
index fc83e060a84369b0032e9d8030ee7754f63f7631..0aec528cde170c1e11ab983708c0a3894c5321d5 100644
--- a/webrtc/modules/bitrate_controller/bitrate_allocator.cc
+++ b/webrtc/modules/bitrate_controller/bitrate_allocator.cc
@@ -51,7 +51,7 @@ BitrateAllocator::ObserverBitrateMap BitrateAllocator::AllocateBitrates() {
 
   uint32_t sum_min_bitrates = 0;
   for (const auto& observer : bitrate_observers_)
-    sum_min_bitrates += observer.second.min_bitrate_;
+    sum_min_bitrates += observer.second.min_bitrate;
   if (last_bitrate_bps_ <= sum_min_bitrates)
     return LowRateAllocation(last_bitrate_bps_);
   else
@@ -59,10 +59,8 @@ BitrateAllocator::ObserverBitrateMap BitrateAllocator::AllocateBitrates() {
 }
 
 int BitrateAllocator::AddBitrateObserver(BitrateObserver* observer,
-                                         uint32_t start_bitrate_bps,
                                          uint32_t min_bitrate_bps,
-                                         uint32_t max_bitrate_bps,
-                                         int* new_observer_bitrate_bps) {
+                                         uint32_t max_bitrate_bps) {
   CriticalSectionScoped lock(crit_sect_.get());
 
   BitrateObserverConfList::iterator it =
@@ -73,43 +71,25 @@ int BitrateAllocator::AddBitrateObserver(BitrateObserver* observer,
   // properly allocate bitrate. The allocator should instead distribute any
   // extra bitrate after all streams have maxed out.
   max_bitrate_bps *= kTransmissionMaxBitrateMultiplier;
-  int new_bwe_candidate_bps = 0;
   if (it != bitrate_observers_.end()) {
     // Update current configuration.
-    it->second.start_bitrate_ = start_bitrate_bps;
-    it->second.min_bitrate_ = min_bitrate_bps;
-    it->second.max_bitrate_ = max_bitrate_bps;
-    // Set the send-side bandwidth to the max of the sum of start bitrates and
-    // the current estimate, so that if the user wants to immediately use more
-    // bandwidth, that can be enforced.
-    for (const auto& observer : bitrate_observers_)
-      new_bwe_candidate_bps += observer.second.start_bitrate_;
+    it->second.min_bitrate = min_bitrate_bps;
+    it->second.max_bitrate = max_bitrate_bps;
   } else {
     // Add new settings.
     bitrate_observers_.push_back(BitrateObserverConfiguration(
-        observer, BitrateConfiguration(start_bitrate_bps, min_bitrate_bps,
-                                       max_bitrate_bps)));
+        observer, BitrateConfiguration(min_bitrate_bps, max_bitrate_bps)));
     bitrate_observers_modified_ = true;
-
-    // TODO(andresp): This is a ugly way to set start bitrate.
-    //
-    // Only change start bitrate if we have exactly one observer. By definition
-    // you can only have one start bitrate, once we have our first estimate we
-    // will adapt from there.
-    if (bitrate_observers_.size() == 1)
-      new_bwe_candidate_bps = start_bitrate_bps;
   }
 
-  last_bitrate_bps_ = std::max<int>(new_bwe_candidate_bps, last_bitrate_bps_);
-
   ObserverBitrateMap allocation = AllocateBitrates();
-  *new_observer_bitrate_bps = 0;
+  int new_observer_bitrate_bps = 0;
   for (auto& kv : allocation) {
     kv.first->OnNetworkChanged(kv.second, last_fraction_loss_, last_rtt_);
     if (kv.first == observer)
-      *new_observer_bitrate_bps = kv.second;
+      new_observer_bitrate_bps = kv.second;
   }
-  return last_bitrate_bps_;
+  return new_observer_bitrate_bps;
 }
 
 void BitrateAllocator::RemoveBitrateObserver(BitrateObserver* observer) {
@@ -129,8 +109,8 @@ void BitrateAllocator::GetMinMaxBitrateSumBps(int* min_bitrate_sum_bps,
 
   CriticalSectionScoped lock(crit_sect_.get());
   for (const auto& observer : bitrate_observers_) {
-    *min_bitrate_sum_bps += observer.second.min_bitrate_;
-    *max_bitrate_sum_bps += observer.second.max_bitrate_;
+    *min_bitrate_sum_bps += observer.second.min_bitrate;
+    *max_bitrate_sum_bps += observer.second.max_bitrate;
   }
 }
 
@@ -160,15 +140,15 @@ BitrateAllocator::ObserverBitrateMap BitrateAllocator::NormalRateAllocation(
   ObserverSortingMap list_max_bitrates;
   for (const auto& observer : bitrate_observers_) {
     list_max_bitrates.insert(std::pair<uint32_t, ObserverConfiguration>(
-        observer.second.max_bitrate_,
-        ObserverConfiguration(observer.first, observer.second.min_bitrate_)));
+        observer.second.max_bitrate,
+        ObserverConfiguration(observer.first, observer.second.min_bitrate)));
   }
   ObserverBitrateMap allocation;
   ObserverSortingMap::iterator max_it = list_max_bitrates.begin();
   while (max_it != list_max_bitrates.end()) {
     number_of_observers--;
     uint32_t observer_allowance =
-        max_it->second.min_bitrate_ + bitrate_per_observer;
+        max_it->second.min_bitrate + bitrate_per_observer;
     if (max_it->first < observer_allowance) {
       // We have more than enough for this observer.
       // Carry the remainder forward.
@@ -176,9 +156,9 @@ BitrateAllocator::ObserverBitrateMap BitrateAllocator::NormalRateAllocation(
       if (number_of_observers != 0) {
         bitrate_per_observer += remainder / number_of_observers;
       }
-      allocation[max_it->second.observer_] = max_it->first;
+      allocation[max_it->second.observer] = max_it->first;
     } else {
-      allocation[max_it->second.observer_] = observer_allowance;
+      allocation[max_it->second.observer] = observer_allowance;
     }
     list_max_bitrates.erase(max_it);
     // Prepare next iteration.
@@ -193,14 +173,14 @@ BitrateAllocator::ObserverBitrateMap BitrateAllocator::LowRateAllocation(
   if (enforce_min_bitrate_) {
     // Min bitrate to all observers.
     for (const auto& observer : bitrate_observers_)
-      allocation[observer.first] = observer.second.min_bitrate_;
+      allocation[observer.first] = observer.second.min_bitrate;
   } else {
-    // Allocate up to |min_bitrate_| to one observer at a time, until
+    // Allocate up to |min_bitrate| to one observer at a time, until
     // |bitrate| is depleted.
     uint32_t remainder = bitrate;
     for (const auto& observer : bitrate_observers_) {
       uint32_t allocated_bitrate =
-          std::min(remainder, observer.second.min_bitrate_);
+          std::min(remainder, observer.second.min_bitrate);
       allocation[observer.first] = allocated_bitrate;
       remainder -= allocated_bitrate;
     }