Do not switch to a high-cost connection that is not receiving

webrtc/p2p/base/p2ptransportchannel.cc

 /*
  *  Copyright 2004 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 165 matching lines @@
 // and the last data received time. This prevents the controlled side from
 // switching the selected connection too frequently when the controlling side
 // is doing aggressive nominations. The precedence of the connection switching
 // criteria is as follows:
 // i) write/receiving/connected states
 // ii) For controlled side,
 //        a) nomination state,
 //        b) last data received time.
 // iii) Lower cost / higher priority.
 // iv) rtt.
+// To further prevent switching to high-cost networks, does not switch to
+// a high-cost connection if it is not receiving.
 // TODO(honghaiz): Stop the aggressive nomination on the controlling side and
 // implement the ice-renomination option.
 bool P2PTransportChannel::ShouldSwitchSelectedConnection(
     Connection* new_connection,
     bool* missed_receiving_unchanged_threshold) const {
   if (!new_connection || selected_connection_ == new_connection) {
     return false;
   }
 
   if (selected_connection_ == nullptr) {
     return true;
   }
 
+  // Do not switch to a connection that is not receiving if it has higher cost
+  // because it may be just spuriously better.
+  if (new_connection->ComputeNetworkCost() >
+          selected_connection_->ComputeNetworkCost() &&
+      !new_connection->receiving()) {
+    return false;
+  }
+
   rtc::Optional<int64_t> receiving_unchanged_threshold(
       rtc::TimeMillis() - config_.receiving_switching_delay.value_or(0));
   int cmp = CompareConnections(selected_connection_, new_connection,
                                receiving_unchanged_threshold,
                                missed_receiving_unchanged_threshold);
   if (cmp != 0) {
     return cmp < 0;
   }
 
   // If everything else is the same, switch only if rtt has improved by
@@ skipping 1306 matching lines @@
   }
 
   // If the channel is weakly connected, ping all connections.
   if (weak()) {
     return true;
   }
 
   // Always ping active connections regardless whether the channel is completed
   // or not, but backup connections are pinged at a slower rate.
   if (IsBackupConnection(conn)) {
-    return (now >= conn->last_ping_response_received() +
+    return conn->rtt_samples() == 0 ||
+           (now >= conn->last_ping_response_received() +
                        config_.backup_connection_ping_interval);
   }
   // Don't ping inactive non-backup connections.
   if (!conn->active()) {
     return false;
   }
 
   // Do ping unwritable, active connections.
   if (!conn->writable()) {
     return true;
@@ skipping 393 matching lines @@
 
   // During the initial state when nothing has been pinged yet, return the first
   // one in the ordered |connections_|.
   return *(std::find_if(connections_.begin(), connections_.end(),
                         [conn1, conn2](Connection* conn) {
                           return conn == conn1 || conn == conn2;
                         }));
 }
 
 }  // namespace cricket