diff --git a/pc/channel.cc b/pc/channel.cc
index 4318aae..3950c03 100644
--- a/pc/channel.cc
+++ b/pc/channel.cc
@@ -174,8 +174,6 @@
   // channel to signal.
   rtp_transport_->SignalPacketReceived.connect(this,
                                                &BaseChannel::OnPacketReceived);
-  rtp_transport_->SignalNetworkRouteChanged.connect(
-      this, &BaseChannel::OnNetworkRouteChanged);
   RTC_LOG(LS_INFO) << "Created channel for " << content_name;
 }
 
@@ -303,7 +301,7 @@
     transport_name_ = rtp_dtls_transport->transport_name();
     debug_name = transport_name_;
   } else {
-    debug_name = rtp_packet_transport->transport_name();
+    debug_name = rtp_packet_transport->debug_name();
   }
   if (rtp_packet_transport == rtp_transport_->rtp_packet_transport()) {
     // Nothing to do if transport isn't changing.
@@ -346,9 +344,6 @@
     DtlsTransportInternal* new_dtls_transport,
     rtc::PacketTransportInternal* new_packet_transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
-  if (new_dtls_transport) {
-    RTC_DCHECK(new_dtls_transport == new_packet_transport);
-  }
   DtlsTransportInternal*& old_dtls_transport =
       rtcp ? rtcp_dtls_transport_ : rtp_dtls_transport_;
   rtc::PacketTransportInternal* old_packet_transport =
@@ -403,14 +398,21 @@
   transport->SignalWritableState.connect(this, &BaseChannel::OnWritableState);
   transport->SignalDtlsState.connect(this, &BaseChannel::OnDtlsState);
   transport->SignalSentPacket.connect(this, &BaseChannel::SignalSentPacket_n);
+  transport->ice_transport()->SignalSelectedCandidatePairChanged.connect(
+      this, &BaseChannel::OnSelectedCandidatePairChanged);
 }
 
 void BaseChannel::DisconnectFromDtlsTransport(
     DtlsTransportInternal* transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
+  OnSelectedCandidatePairChanged(transport->ice_transport(), nullptr, -1,
+                                 false);
+
   transport->SignalWritableState.disconnect(this);
   transport->SignalDtlsState.disconnect(this);
   transport->SignalSentPacket.disconnect(this);
+  transport->ice_transport()->SignalSelectedCandidatePairChanged.disconnect(
+      this);
 }
 
 void BaseChannel::ConnectToPacketTransport(
@@ -590,24 +592,29 @@
   }
 }
 
-void BaseChannel::OnNetworkRouteChanged(
-    rtc::Optional<rtc::NetworkRoute> network_route) {
+void BaseChannel::OnSelectedCandidatePairChanged(
+    IceTransportInternal* ice_transport,
+    CandidatePairInterface* selected_candidate_pair,
+    int last_sent_packet_id,
+    bool ready_to_send) {
+  RTC_DCHECK((rtp_dtls_transport_ &&
+              ice_transport == rtp_dtls_transport_->ice_transport()) ||
+             (rtcp_dtls_transport_ &&
+              ice_transport == rtcp_dtls_transport_->ice_transport()));
   RTC_DCHECK(network_thread_->IsCurrent());
-  rtc::NetworkRoute new_route;
-  if (network_route) {
-    invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_, [=] {
-      media_channel_->OnTransportOverheadChanged(
-          network_route->packet_overhead);
-    });
-    new_route = *(network_route);
-  }
+  selected_candidate_pair_ = selected_candidate_pair;
+  std::string transport_name = ice_transport->transport_name();
+  rtc::NetworkRoute network_route;
+  if (selected_candidate_pair) {
+    network_route = rtc::NetworkRoute(
+        ready_to_send, selected_candidate_pair->local_candidate().network_id(),
+        selected_candidate_pair->remote_candidate().network_id(),
+        last_sent_packet_id);
 
-  // Note: When the RTCP-muxing is not enabled, RTCP transport and RTP transport
-  // use the same transport name and MediaChannel::OnNetworkRouteChanged cannot
-  // work correctly. Intentionally leave it broken to simplify the code and
-  // encourage the users to stop using non-muxing RTCP.
+    UpdateTransportOverhead();
+  }
   invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_, [=] {
-    media_channel_->OnNetworkRouteChanged(transport_name_, new_route);
+    media_channel_->OnNetworkRouteChanged(transport_name, network_route);
   });
 }
 
@@ -908,8 +915,9 @@
 
   if (!ret) {
     RTC_LOG(LS_WARNING) << "DTLS-SRTP key installation failed";
+  } else {
+    UpdateTransportOverhead();
   }
-
   return ret;
 }
 
@@ -1013,7 +1021,6 @@
   if (srtp_transport_ == nullptr) {
     rtp_transport_->SignalReadyToSend.disconnect(this);
     rtp_transport_->SignalPacketReceived.disconnect(this);
-    rtp_transport_->SignalNetworkRouteChanged.disconnect(this);
 
     auto transport = rtc::MakeUnique<webrtc::SrtpTransport>(
         std::move(rtp_transport_), content_name_);
@@ -1024,8 +1031,6 @@
         this, &BaseChannel::OnTransportReadyToSend);
     rtp_transport_->SignalPacketReceived.connect(
         this, &BaseChannel::OnPacketReceived);
-    rtp_transport_->SignalNetworkRouteChanged.connect(
-        this, &BaseChannel::OnNetworkRouteChanged);
     RTC_LOG(LS_INFO) << "Wrapping RtpTransport in SrtpTransport.";
   }
 }
@@ -1155,7 +1160,7 @@
         // the RTCP transport.
         std::string debug_name =
             transport_name_.empty()
-                ? rtp_transport_->rtp_packet_transport()->transport_name()
+                ? rtp_transport_->rtp_packet_transport()->debug_name()
                 : transport_name_;
         RTC_LOG(LS_INFO) << "Enabling rtcp-mux for " << content_name()
                          << "; no longer need RTCP transport for "
@@ -1674,6 +1679,47 @@
       Bind(&BaseChannel::UpdateMediaSendRecvState_w, this));
 }
 
+int BaseChannel::GetTransportOverheadPerPacket() const {
+  RTC_DCHECK(network_thread_->IsCurrent());
+
+  if (!selected_candidate_pair_)
+    return 0;
+
+  int transport_overhead_per_packet = 0;
+
+  constexpr int kIpv4Overhaed = 20;
+  constexpr int kIpv6Overhaed = 40;
+  transport_overhead_per_packet +=
+      selected_candidate_pair_->local_candidate().address().family() == AF_INET
+          ? kIpv4Overhaed
+          : kIpv6Overhaed;
+
+  constexpr int kUdpOverhaed = 8;
+  constexpr int kTcpOverhaed = 20;
+  transport_overhead_per_packet +=
+      selected_candidate_pair_->local_candidate().protocol() ==
+              TCP_PROTOCOL_NAME
+          ? kTcpOverhaed
+          : kUdpOverhaed;
+
+  if (srtp_active()) {
+    int srtp_overhead = 0;
+    if (srtp_transport_->GetSrtpOverhead(&srtp_overhead))
+      transport_overhead_per_packet += srtp_overhead;
+  }
+
+  return transport_overhead_per_packet;
+}
+
+void BaseChannel::UpdateTransportOverhead() {
+  int transport_overhead_per_packet = GetTransportOverheadPerPacket();
+  if (transport_overhead_per_packet)
+    invoker_.AsyncInvoke<void>(
+        RTC_FROM_HERE, worker_thread_,
+        Bind(&MediaChannel::OnTransportOverheadChanged, media_channel_.get(),
+             transport_overhead_per_packet));
+}
+
 void VoiceChannel::UpdateMediaSendRecvState_w() {
   // Render incoming data if we're the active call, and we have the local
   // content. We receive data on the default channel and multiplexed streams.