Start probes only after network is connected.

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 28 matching lines @@
 
 // This is a limit on how often probing can be done when there is a BW
 // drop detected in ALR region.
 constexpr int kAlrProbingIntervalLimitMs = 5000;
 
 }  // 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()) {}
 
 void ProbeController::SetBitrates(int min_bitrate_bps,
                                   int start_bitrate_bps,
                                   int max_bitrate_bps) {
   rtc::CritScope cs(&critsect_);
-  if (state_ == State::kInit) {
-    // When probing at 1.8 Mbps ( 6x 300), this represents a threshold of
-    // 1.2 Mbps to continue probing.
-    InitiateProbing({3 * start_bitrate_bps, 6 * start_bitrate_bps},
-                    4 * start_bitrate_bps);
-  }
+
+  start_bitrate_bps_ =

[philipel, 2016/11/08 09:48:18]

min_bitrate_bps <= start_bitrate_bps <= max_bitrate_bps?

[Sergey Ulanov, 2016/11/08 16:26:01]

This function is called with with start_bitrate_bps = 0 when application doesn't
specify start bitrate. Updated call.cc to always pass non-zero start bitrate and
added a DCHECK here.

+      start_bitrate_bps > 0 ? start_bitrate_bps : min_bitrate_bps;
 
   int old_max_bitrate_bps = max_bitrate_bps_;
   max_bitrate_bps_ = max_bitrate_bps;
 
-  // Only do probing if:
-  //   we are mid-call, which we consider to be if
-  //     exponential probing is not active and
-  //     |estimated_bitrate_bps_| is valid (> 0) and
-  //     the current bitrate is lower than the new |max_bitrate_bps|, and
-  //     |max_bitrate_bps_| was increased.
-  if (state_ != State::kWaitingForProbingResult &&
-      estimated_bitrate_bps_ != 0 &&
-      estimated_bitrate_bps_ < old_max_bitrate_bps &&
-      max_bitrate_bps_ > old_max_bitrate_bps) {
-    InitiateProbing({max_bitrate_bps}, kExponentialProbingDisabled);
+  switch (state_) {
+    case State::kInit:
+      if (network_state_ == kNetworkUp)
+        InitiateExponentialProbing();
+      break;
+
+    case State::kWaitingForProbingResult:
+      break;
+
+    case State::kProbingComplete:
+      // Initiate probing when |max_bitrate_| was increased mid-call.
+      if (estimated_bitrate_bps_ != 0 &&
+          estimated_bitrate_bps_ < old_max_bitrate_bps &&
+          max_bitrate_bps_ > old_max_bitrate_bps) {
+        InitiateProbing({max_bitrate_bps}, kExponentialProbingDisabled);
+      }
+      break;
   }
 }
 
+void ProbeController::OnNetworkStateChanged(NetworkState state) {

[philipel, 2016/11/08 09:48:18]

Maybe rename |state| to |network_state|, slightly confusing that |state_| and
|state| are two different types.

[Sergey Ulanov, 2016/11/08 16:26:01]

Done.

+  rtc::CritScope cs(&critsect_);
+  network_state_ = state;
+  if (network_state_ == kNetworkUp && state_ == State::kInit)
+    InitiateExponentialProbing();
+}
+
+void ProbeController::InitiateExponentialProbing() {
+  RTC_DCHECK(network_state_ == kNetworkUp);
+  RTC_DCHECK(state_ == State::kInit);
+  RTC_DCHECK_GT(start_bitrate_bps_, 0);
+
+  // When probing at 1.8 Mbps ( 6x 300), this represents a threshold of
+  // 1.2 Mbps to continue probing.
+  InitiateProbing({3 * start_bitrate_bps_, 6 * start_bitrate_bps_},
+                  4 * start_bitrate_bps_);
+}
+
 void ProbeController::SetEstimatedBitrate(int bitrate_bps) {
   rtc::CritScope cs(&critsect_);
   if (state_ == State::kWaitingForProbingResult) {
     if ((clock_->TimeInMilliseconds() - 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
@@ skipping 53 matching lines @@
   }
   min_bitrate_to_probe_further_bps_ = min_bitrate_to_probe_further_bps;
   time_last_probing_initiated_ms_ = clock_->TimeInMilliseconds();
   if (min_bitrate_to_probe_further_bps == kExponentialProbingDisabled)
     state_ = State::kProbingComplete;
   else
     state_ = State::kWaitingForProbingResult;
 }
 
 }  // namespace webrtc