Probing: Add support for exponential startup probing

webrtc/modules/bitrate_controller/bitrate_controller_impl.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 13 matching lines @@
 class BitrateControllerImpl::RtcpBandwidthObserverImpl
     : public RtcpBandwidthObserver {
  public:
   explicit RtcpBandwidthObserverImpl(BitrateControllerImpl* owner)
       : owner_(owner) {
   }
   virtual ~RtcpBandwidthObserverImpl() {
   }
   // Received RTCP REMB or TMMBR.
   void OnReceivedEstimatedBitrate(uint32_t bitrate) override {
-    owner_->OnReceivedEstimatedBitrate(bitrate);
+    owner_->OnReceiverEstimatedBitrate(bitrate);
   }
   // Received RTCP receiver block.
   void OnReceivedRtcpReceiverReport(const ReportBlockList& report_blocks,
                                     int64_t rtt,
                                     int64_t now_ms) override {
     if (report_blocks.empty())
       return;
 
     int fraction_lost_aggregate = 0;
     int total_number_of_packets = 0;
@@ skipping 121 matching lines @@
 }
 
 void BitrateControllerImpl::SetReservedBitrate(uint32_t reserved_bitrate_bps) {
   {
     rtc::CritScope cs(&critsect_);
     reserved_bitrate_bps_ = reserved_bitrate_bps;
   }
   MaybeTriggerOnNetworkChanged();
 }
 
-void BitrateControllerImpl::OnReceivedEstimatedBitrate(uint32_t bitrate) {
+// This is called upon reception of REMB or TMMBR.
+void BitrateControllerImpl::OnReceiverEstimatedBitrate(uint32_t bitrate) {
   {
     rtc::CritScope cs(&critsect_);
     bandwidth_estimation_.UpdateReceiverEstimate(clock_->TimeInMilliseconds(),
                                                  bitrate);
   }
   MaybeTriggerOnNetworkChanged();
 }
 
-void BitrateControllerImpl::UpdateProbeBitrate(uint32_t bitrate_bps) {
+void BitrateControllerImpl::OnProbeBitrate(uint32_t bitrate_bps) {
   {
     rtc::CritScope cs(&critsect_);
     bandwidth_estimation_.SetSendBitrate(bitrate_bps);
   }
   MaybeTriggerOnNetworkChanged();
 }
 
-void BitrateControllerImpl::UpdateDelayBasedEstimate(uint32_t bitrate_bps) {
+// TODO(isheriff): Perhaps need new interface for invocation from DelayBasedBwe.
+void BitrateControllerImpl::OnReceiveBitrateChanged(
+    const std::vector<uint32_t>& ssrcs,
+    uint32_t bitrate_bps) {
   {
     rtc::CritScope cs(&critsect_);
     bandwidth_estimation_.UpdateDelayBasedEstimate(clock_->TimeInMilliseconds(),
                                                    bitrate_bps);
   }
   MaybeTriggerOnNetworkChanged();
 }
 
 int64_t BitrateControllerImpl::TimeUntilNextProcess() {
   const int64_t kBitrateControllerUpdateIntervalMs = 25;
@@ skipping 72 matching lines @@
   bandwidth_estimation_.CurrentEstimate(&bitrate, &fraction_loss, &rtt);
   if (bitrate > 0) {
     bitrate = bitrate - std::min<int>(bitrate, reserved_bitrate_bps_);
     bitrate = std::max(bitrate, bandwidth_estimation_.GetMinBitrate());
     *bandwidth = bitrate;
     return true;
   }
   return false;
 }
 }  // namespace webrtc