Fix exponential probing in ProbeController.

webrtc/modules/congestion_controller/probe_controller.cc

 /*
  *  Copyright (c) 2016 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 103 matching lines @@
   InitiateProbing(clock_->TimeInMilliseconds(),
                   {3 * start_bitrate_bps_, 6 * start_bitrate_bps_},
                   4 * start_bitrate_bps_);
 }
 
 void ProbeController::SetEstimatedBitrate(int bitrate_bps) {
   rtc::CritScope cs(&critsect_);
   int64_t now_ms = clock_->TimeInMilliseconds();
 
   if (state_ == State::kWaitingForProbingResult) {
-    if ((now_ms - time_last_probing_initiated_ms_) >
-        kMaxWaitingTimeForProbingResultMs) {
-      LOG(LS_INFO) << "kWaitingForProbingResult: timeout";
-      state_ = State::kProbingComplete;
-      min_bitrate_to_probe_further_bps_ = kExponentialProbingDisabled;
-    } else {
-      // Continue probing if probing results indicate channel has greater
-      // capacity.
-      LOG(LS_INFO) << "Measured bitrate: " << bitrate_bps
-                   << " Minimum to probe further: "
-                   << min_bitrate_to_probe_further_bps_;
-      if (min_bitrate_to_probe_further_bps_ != kExponentialProbingDisabled &&
-          bitrate_bps > min_bitrate_to_probe_further_bps_) {
-        // Double the probing bitrate and expect a minimum of 25% gain to
-        // continue probing.
-        InitiateProbing(now_ms, {2 * bitrate_bps},
-                        bitrate_bps * kRepeatedProbeMinPercentage / 100);
-      } else {
-        // Stop exponential probing.
-        state_ = State::kProbingComplete;
-        min_bitrate_to_probe_further_bps_ = kExponentialProbingDisabled;
-      }
+    // Continue probing if probing results indicate channel has greater
+    // capacity.
+    LOG(LS_INFO) << "Measured bitrate: " << bitrate_bps
+                 << " Minimum to probe further: "
+                 << min_bitrate_to_probe_further_bps_;
+    if (min_bitrate_to_probe_further_bps_ != kExponentialProbingDisabled &&
+        bitrate_bps > min_bitrate_to_probe_further_bps_) {
+      // Double the probing bitrate and expect a minimum of 25% gain to
+      // continue probing.
+      InitiateProbing(now_ms, {2 * bitrate_bps},
+                      bitrate_bps * kRepeatedProbeMinPercentage / 100);
     }
   }
 
   // Detect a drop in estimated BW when operating in ALR and not already
   // probing. The current response is to initiate a single probe session at the
   // previous bitrate and immediately use the reported bitrate as the new
   // bitrate.
   //
   // If the probe session fails, the assumption is that this drop was a
   // real one from a competing flow or something else on the network and
@@ skipping 19 matching lines @@
 }
 
 void ProbeController::EnablePeriodicAlrProbing(bool enable) {
   rtc::CritScope cs(&critsect_);
   enable_periodic_alr_probing_ = enable;
 }
 
 void ProbeController::Process() {
   rtc::CritScope cs(&critsect_);
 
+  int64_t now_ms = clock_->TimeInMilliseconds();
+
+  if (state_ == State::kWaitingForProbingResult &&
+      (now_ms - time_last_probing_initiated_ms_) >
+          kMaxWaitingTimeForProbingResultMs) {
+    LOG(LS_INFO) << "kWaitingForProbingResult: timeout";
+    state_ = State::kProbingComplete;
+    min_bitrate_to_probe_further_bps_ = kExponentialProbingDisabled;
+  }
+
   if (state_ != State::kProbingComplete || !enable_periodic_alr_probing_)
     return;
 
   // Probe bandwidth periodically when in ALR state.
   rtc::Optional<int64_t> alr_start_time =
       pacer_->GetApplicationLimitedRegionStartTime();
   if (alr_start_time) {
-    int64_t now_ms = clock_->TimeInMilliseconds();
     int64_t next_probe_time_ms =
         std::max(*alr_start_time, time_last_probing_initiated_ms_) +
         kAlrPeriodicProbingIntervalMs;
     if (now_ms >= next_probe_time_ms) {
       InitiateProbing(
           now_ms, {estimated_bitrate_bps_ * 2},
           estimated_bitrate_bps_ * kRepeatedProbeMinPercentage / 100);
     }
   }
 }
@@ skipping 16 matching lines @@
   }
   min_bitrate_to_probe_further_bps_ = min_bitrate_to_probe_further_bps;
   time_last_probing_initiated_ms_ = now_ms;
   if (min_bitrate_to_probe_further_bps == kExponentialProbingDisabled)
     state_ = State::kProbingComplete;
   else
     state_ = State::kWaitingForProbingResult;
 }
 
 }  // namespace webrtc