Do not switch a connection if the new connection is not ready to send packets.

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 173 matching lines @@
 // ii) For controlled side,
 //        a) nomination state,
 //        b) last data received time.
 // iii) Lower cost / higher priority.
 // iv) rtt.
 // 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) {
+  if (!ReadyToSend(new_connection) || selected_connection_ == new_connection) {
     return false;
   }
 
   if (selected_connection_ == nullptr) {
     return true;
   }
 
   rtc::Optional<int64_t> receiving_unchanged_threshold(
       rtc::TimeMillis() - config_.receiving_switching_delay.value_or(0));
   int cmp = CompareConnections(selected_connection_, new_connection,
@@ skipping 728 matching lines @@
 int P2PTransportChannel::SendPacket(const char *data, size_t len,
                                     const rtc::PacketOptions& options,
                                     int flags) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   if (flags != 0) {
     error_ = EINVAL;
     return -1;
   }
   // If we don't think the connection is working yet, return ENOTCONN
   // instead of sending a packet that will probably be dropped.
-  if (!ReadyToSend()) {
+  if (!ReadyToSend(selected_connection_)) {
     error_ = ENOTCONN;
     return -1;
   }
 
   last_sent_packet_id_ = options.packet_id;
   int sent = selected_connection_->Send(data, len, options);
   if (sent <= 0) {
     ASSERT(sent < 0);
     error_ = selected_connection_->GetError();
   }
@@ skipping 354 matching lines @@
     // send; then it will only signal ready-to-send if the media channel
     // has been disallowed to send.
     if (selected_connection_->writable() ||
         PresumedWritable(selected_connection_)) {
       SignalReadyToSend(this);
     }
   } else {
     LOG_J(LS_INFO, this) << "No selected connection";
   }
   SignalSelectedCandidatePairChanged(this, selected_connection_,
-                                     last_sent_packet_id_, ReadyToSend());
+                                     last_sent_packet_id_,
+                                     ReadyToSend(selected_connection_));
 }
 
 // Warning: UpdateState should eventually be called whenever a connection
 // is added, deleted, or the write state of any connection changes so that the
 // transport controller will get the up-to-date channel state. However it
 // should not be called too often; in the case that multiple connection states
 // change, it should be called after all the connection states have changed. For
 // example, we call this at the end of SortConnectionsAndUpdateState.
 void P2PTransportChannel::UpdateState() {
   TransportChannelState state = ComputeState();
@@ skipping 73 matching lines @@
 void P2PTransportChannel::HandleAllTimedOut() {
   for (Connection* connection : connections_) {
     connection->Destroy();
   }
 }
 
 bool P2PTransportChannel::weak() const {
   return !selected_connection_ || selected_connection_->weak();
 }
 
-bool P2PTransportChannel::ReadyToSend() const {
+bool P2PTransportChannel::ReadyToSend(Connection* connection) const {
   // Note that we allow sending on an unreliable connection, because it's
   // possible that it became unreliable simply due to bad chance.
   // So this shouldn't prevent attempting to send media.
-  return selected_connection_ != nullptr &&
-         (selected_connection_->writable() ||
-          PresumedWritable(selected_connection_) ||
-          selected_connection_->write_state() ==
-              Connection::STATE_WRITE_UNRELIABLE);
+  return connection != nullptr &&
+         (connection->writable() ||
+          connection->write_state() == Connection::STATE_WRITE_UNRELIABLE ||
+          PresumedWritable(connection));
 }
 
 // If we have a selected connection, return it, otherwise return top one in the
 // list (later we will mark it best).
 Connection* P2PTransportChannel::GetBestConnectionOnNetwork(
     rtc::Network* network) const {
   // If the selected connection is on this network, then it wins.
   if (selected_connection_ &&
       (selected_connection_->port()->Network() == network)) {
     return selected_connection_;
@@ skipping 501 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