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_ =
+      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 &&
+  if (state_ == State::kProbingComplete &&
       estimated_bitrate_bps_ != 0 &&
       estimated_bitrate_bps_ < old_max_bitrate_bps &&
       max_bitrate_bps_ > old_max_bitrate_bps) {
     InitiateProbing({max_bitrate_bps}, kExponentialProbingDisabled);
   }
+
+  MaybeInitiateProbing();

[honghaiz3, 2016/11/07 23:31:41]

It is a little strange here that you may have called InitiateProbing and then
call MaybeInitiateProbing again (I know it won't be called twice because of the
state, but it still looks strange).  
Possible options I would suggest:
1. Do MaybeInitiateProbing under an else clause. 
2. Inline the MaybeInitiateProbing and have a switch-case or if-else based on
different state_. 
3. Or maybe something else to avoid the potential double-calling. 

[Sergey Ulanov, 2016/11/08 00:10:57]

Replaced MaybeIntiiateProbing() with InitiateExponentialProbing() and added a
switch statement.

+}
+
+void ProbeController::OnNetworkStateChanged(NetworkState state) {
+  rtc::CritScope cs(&critsect_);
+  network_state_ = state;
+  MaybeInitiateProbing();
+}
+
+void ProbeController::MaybeInitiateProbing() {
+  if (network_state_ == kNetworkUp && 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;
@@ skipping 55 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