如果之前没有选择connection，则就用排序好的第一个connection。否则，就要将当前使用的connection和排序后的第一个connection做比较，看哪个更佳就选哪个。
续上一节。

BasicIceController::SortAndSwitchConnection

image.png

BasicIceController::ShouldSwitchConnection

image.png
selectedconnection 之前前选中的connection
new_connection 排序后的选中connection

  1. IceControllerInterface::SwitchResult BasicIceController::ShouldSwitchConnection(
  2.     IceControllerEvent reason,
  3.     const Connection* new_connection) {
  4.   if (!ReadyToSend(new_connection) || selected_connection_ == new_connection) {
  5.     return {absl::nullopt, absl::nullopt};
  6.   }
  8.   if (selected_connection_ == nullptr) {  // 第一次进来这里
  9.     return HandleInitialSelectDampening(reason, new_connection);
  10.   }
  12.   // Do not switch to a connection that is not receiving if it is not on a
  13.   // preferred network or it has higher cost because it may be just spuriously
  14.   // better.
  15.   int compare_a_b_by_networks = CompareCandidatePairNetworks(
  16.       new_connection, selected_connection_, config_.network_preference);
  17.   if (compare_a_b_by_networks == b_is_better && !new_connection->receiving()) {
  18.     return {absl::nullopt, absl::nullopt};
  19.   }
  21.   bool missed_receiving_unchanged_threshold = false;
  22.   absl::optional<int64_t> receiving_unchanged_threshold(
  23.       rtc::TimeMillis() - config_.receiving_switching_delay_or_default());
  24.   int cmp = CompareConnections(selected_connection_, new_connection,
  25.                                receiving_unchanged_threshold,
  26.                                &missed_receiving_unchanged_threshold);
  28.   absl::optional<IceControllerEvent> recheck_event;
  29.   if (missed_receiving_unchanged_threshold &&
  30.       config_.receiving_switching_delay_or_default()) {
  31.     // If we do not switch to the connection because it missed the receiving
  32.     // threshold, the new connection is in a better receiving state than the
  33.     // currently selected connection. So we need to re-check whether it needs
  34.     // to be switched at a later time.
  35.     recheck_event = reason;
  36.     recheck_event->recheck_delay_ms =
  37.         config_.receiving_switching_delay_or_default();
  38.   }
  40.   if (cmp < 0) {
  41.     return {new_connection, absl::nullopt};
  42.   } else if (cmp > 0) {
  43.     return {absl::nullopt, recheck_event};
  44.   }
  46.   // If everything else is the same, switch only if rtt has improved by
  47.   // a margin.
  48.   if (new_connection->rtt() <= selected_connection_->rtt() - kMinImprovement) {
  49.     return {new_connection, absl::nullopt};
  50.   }
  52.   return {absl::nullopt, recheck_event};
  53. }

BasicIceController::HandleInitialSelectDampening

如果一开始没有选出connection，则进来这里。

image.png
跟踪代码，只执行截图里面的if语句。。

  1. IceControllerInterface::SwitchResult
  2. BasicIceController::HandleInitialSelectDampening(
  3.     IceControllerEvent reason,
  4.     const Connection* new_connection) {
  5.   if (!field_trials_->initial_select_dampening.has_value() &&
  6.       !field_trials_->initial_select_dampening_ping_received.has_value()) {
  7.     // experiment not enabled => select connection.
  8.     return {new_connection, absl::nullopt};
  9.   }
  11.   int64_t now = rtc::TimeMillis();
  12.   int64_t max_delay = 0;
  13.   if (new_connection->last_ping_received() > 0 &&
  14.       field_trials_->initial_select_dampening_ping_received.has_value()) {
  15.     max_delay = *field_trials_->initial_select_dampening_ping_received;
  16.   } else if (field_trials_->initial_select_dampening.has_value()) {
  17.     max_delay = *field_trials_->initial_select_dampening;
  18.   }
  20.   int64_t start_wait =
  21.       initial_select_timestamp_ms_ == 0 ? now : initial_select_timestamp_ms_;
  22.   int64_t max_wait_until = start_wait + max_delay;
  24.   if (now >= max_wait_until) {
  25.     RTC_LOG(LS_INFO) << "reset initial_select_timestamp_ = "
  26.                      << initial_select_timestamp_ms_
  27.                      << " selection delayed by: " << (now - start_wait) << "ms";
  28.     initial_select_timestamp_ms_ = 0;
  29.     return {new_connection, absl::nullopt};
  30.   }
  32.   // We are not yet ready to select first connection...
  33.   if (initial_select_timestamp_ms_ == 0) {
  34.     // Set timestamp on first time...
  35.     // but run the delayed invokation everytime to
  36.     // avoid possibility that we miss it.
  37.     initial_select_timestamp_ms_ = now;
  38.     RTC_LOG(LS_INFO) << "set initial_select_timestamp_ms_ = "
  39.                      << initial_select_timestamp_ms_;
  40.   }
  42.   int min_delay = max_delay;
  43.   if (field_trials_->initial_select_dampening.has_value()) {
  44.     min_delay = std::min(min_delay, *field_trials_->initial_select_dampening);
  45.   }
  46.   if (field_trials_->initial_select_dampening_ping_received.has_value()) {
  47.     min_delay = std::min(
  48.         min_delay, *field_trials_->initial_select_dampening_ping_received);
  49.   }
  51.   RTC_LOG(LS_INFO) << "delay initial selection up to " << min_delay << "ms";
  52.   reason.type = IceControllerEvent::ICE_CONTROLLER_RECHECK;
  53.   reason.recheck_delay_ms = min_delay;
  54.   return {absl::nullopt, reason};
  55. }

P2PTransportChannel::OnNominated(Connection* conn)
-》
P2PTransportChannel::MaybeSwitchSelectedConnection

P2PTransportChannel::SortConnectionsAndUpdateState
-》
P2PTransportChannel::MaybeSwitchSelectedConnection

P2PTransportChannel::MaybeSwitchSelectedConnection

image.png

P2PTransportChannel::SwitchSelectedConnection

image.png
到这里就已经完成了选择connection。

  1. // Change the selected connection, and let listeners know.
  2. void P2PTransportChannel::SwitchSelectedConnection(Connection* conn,
  3.                                                    IceControllerEvent reason) {
  4.   RTC_DCHECK_RUN_ON(network_thread_);
  5.   // Note: if conn is NULL, the previous |selected_connection_| has been
  6.   // destroyed, so don't use it.
  7.   Connection* old_selected_connection = selected_connection_;
  8.   selected_connection_ = conn;
  9.   LogCandidatePairConfig(conn, webrtc::IceCandidatePairConfigType::kSelected);
  10.   network_route_.reset();
  11.   if (old_selected_connection) {
  12.     old_selected_connection->set_selected(false);
  13.   }
  14.   if (selected_connection_) {
  15.     ++nomination_;
  16.     selected_connection_->set_selected(true);
  17.     if (old_selected_connection) {
  18.       RTC_LOG(LS_INFO) << ToString() << ": Previous selected connection: "
  19.                        << old_selected_connection->ToString();
  20.     }
  21.     RTC_LOG(LS_INFO) << ToString() << ": New selected connection: "
  22.                      << selected_connection_->ToString();
  23.     SignalRouteChange(this, selected_connection_->remote_candidate());
  24.     // This is a temporary, but safe fix to webrtc issue 5705.
  25.     // TODO(honghaiz): Make all ENOTCONN error routed through the transport
  26.     // channel so that it knows whether the media channel is allowed to
  27.     // send; then it will only signal ready-to-send if the media channel
  28.     // has been disallowed to send.
  29.     if (selected_connection_->writable() ||
  30.         PresumedWritable(selected_connection_)) {
  31.       SignalReadyToSend(this);
  32.     }
  34.     network_route_.emplace(rtc::NetworkRoute());
  35.     network_route_->connected = ReadyToSend(selected_connection_);
  36.     network_route_->local = CreateRouteEndpointFromCandidate(
  37.         /* local= */ true, selected_connection_->local_candidate(),
  38.         /* uses_turn= */ selected_connection_->port()->Type() ==
  39.             RELAY_PORT_TYPE);
  40.     network_route_->remote = CreateRouteEndpointFromCandidate(
  41.         /* local= */ false, selected_connection_->remote_candidate(),
  42.         /* uses_turn= */ selected_connection_->remote_candidate().type() ==
  43.             RELAY_PORT_TYPE);
  45.     network_route_->last_sent_packet_id = last_sent_packet_id_;
  46.     network_route_->packet_overhead =
  47.         selected_connection_->local_candidate().address().ipaddr().overhead() +
  48.         GetProtocolOverhead(selected_connection_->local_candidate().protocol());
  49.   } else {
  50.     RTC_LOG(LS_INFO) << ToString() << ": No selected connection";
  51.   }
  53.   if (conn != nullptr && ice_role_ == ICEROLE_CONTROLLING &&
  54.       ((field_trials_.send_ping_on_switch_ice_controlling &&
  55.         old_selected_connection != nullptr) ||
  56.        field_trials_.send_ping_on_selected_ice_controlling)) {
  57.     PingConnection(conn);
  58.     MarkConnectionPinged(conn);
  59.   }
  61.   SignalNetworkRouteChanged(network_route_);
  63.   // Create event for candidate pair change.
  64.   if (selected_connection_) {
  65.     CandidatePairChangeEvent pair_change;
  66.     pair_change.reason = reason.ToString();
  67.     pair_change.selected_candidate_pair = *GetSelectedCandidatePair();
  68.     pair_change.last_data_received_ms =
  69.         selected_connection_->last_data_received();
  71.     if (old_selected_connection) {
  72.       pair_change.estimated_disconnected_time_ms =
  73.           ComputeEstimatedDisconnectedTimeMs(rtc::TimeMillis(),
  74.                                              old_selected_connection);
  75.     } else {
  76.       pair_change.estimated_disconnected_time_ms = 0;
  77.     }
  79.     SignalCandidatePairChanged(pair_change);
  80.   }
  82.   ++selected_candidate_pair_changes_;
  84.   ice_controller_->SetSelectedConnection(selected_connection_);
  85. }

可能切换连接的几种情况

image.png