Perform probing on network route change.

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 32 matching lines @@
 // relative to the previous probe. For example, if 1Mbps probe results in
 // 80kbps, then we'll probe again at 1.6Mbps. In that case second probe won't be
 // sent if we get 600kbps from the first one.
 constexpr int kRepeatedProbeMinPercentage = 70;
 
 }  // namespace
 
 ProbeController::ProbeController(PacedSender* pacer, Clock* clock)
     : pacer_(pacer),
       clock_(clock),
-      network_state_(kNetworkUp),
-      state_(State::kInit),
-      min_bitrate_to_probe_further_bps_(kExponentialProbingDisabled),
-      time_last_probing_initiated_ms_(0),
-      estimated_bitrate_bps_(0),
-      start_bitrate_bps_(0),
-      max_bitrate_bps_(0),
-      last_alr_probing_time_(clock_->TimeInMilliseconds()),
-      enable_periodic_alr_probing_(false),
-      mid_call_probing_waiting_for_result_(false) {}
+      enable_periodic_alr_probing_(false) {
+        Reset();

[stefan-webrtc, 2017/03/07 12:16:55]

I think indentation is wrong here.

+      }
 
 void ProbeController::SetBitrates(int64_t min_bitrate_bps,
                                   int64_t start_bitrate_bps,
                                   int64_t max_bitrate_bps) {
   rtc::CritScope cs(&critsect_);
 
   if (start_bitrate_bps > 0)  {
     start_bitrate_bps_ = start_bitrate_bps;
   } else if (start_bitrate_bps_ == 0) {
     start_bitrate_bps_ = min_bitrate_bps;
@@ skipping 106 matching lines @@
   }
 
   estimated_bitrate_bps_ = bitrate_bps;
 }
 
 void ProbeController::EnablePeriodicAlrProbing(bool enable) {
   rtc::CritScope cs(&critsect_);
   enable_periodic_alr_probing_ = enable;
 }
 
+void ProbeController::Reset() {
+  rtc::CritScope cs(&critsect_);
+  network_state_ = kNetworkUp;
+  state_ = State::kInit;
+  min_bitrate_to_probe_further_bps_ = kExponentialProbingDisabled;
+  time_last_probing_initiated_ms_ = 0;
+  estimated_bitrate_bps_ = 0;
+  start_bitrate_bps_ = 0;
+  max_bitrate_bps_ = 0;
+  last_alr_probing_time_ = clock_->TimeInMilliseconds();
+  mid_call_probing_waiting_for_result_ = false;

[stefan-webrtc, 2017/03/07 12:16:55]

Can we do something like this instead:
*this = ProbeController(pacer_, clock_);

and keep the initializer list? That reduces the risk of this becoming out of
sync with the members, I think...

[philipel, 2017/03/07 13:09:13]

I can see two problems with that. First, what will happen to the pointer holding
the ProbeController? You might rewrite your local this pointer but the
CongestionController won't know about that. Second, what happens when we destroy
a lock other threads might potentially be waiting to acquire?

[stefan-webrtc, 2017/03/07 13:11:25]

Agree, that seems very risky. :)

+}
+
 void ProbeController::Process() {
   rtc::CritScope cs(&critsect_);
 
   int64_t now_ms = clock_->TimeInMilliseconds();
 
   if (now_ms - time_last_probing_initiated_ms_ >
       kMaxWaitingTimeForProbingResultMs) {
     mid_call_probing_waiting_for_result_ = false;
 
     if (state_ == State::kWaitingForProbingResult) {
@@ skipping 37 matching lines @@
     state_ = State::kWaitingForProbingResult;
     min_bitrate_to_probe_further_bps_ =
         (*(bitrates_to_probe.end() - 1)) * kRepeatedProbeMinPercentage / 100;
   } else {
     state_ = State::kProbingComplete;
     min_bitrate_to_probe_further_bps_ = kExponentialProbingDisabled;
   }
 }
 
 }  // namespace webrtc