diff --git a/pc/channel.cc b/pc/channel.cc
index 3950c03..4318aae 100644
--- a/pc/channel.cc
+++ b/pc/channel.cc
@@ -174,6 +174,8 @@
   // 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;
 }
 
@@ -301,7 +303,7 @@
     transport_name_ = rtp_dtls_transport->transport_name();
     debug_name = transport_name_;
   } else {
-    debug_name = rtp_packet_transport->debug_name();
+    debug_name = rtp_packet_transport->transport_name();
   }
   if (rtp_packet_transport == rtp_transport_->rtp_packet_transport()) {
     // Nothing to do if transport isn't changing.
@@ -344,6 +346,9 @@
     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 =
@@ -398,21 +403,14 @@
   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(
@@ -592,29 +590,24 @@
   }
 }
 
-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()));
+void BaseChannel::OnNetworkRouteChanged(
+    rtc::Optional<rtc::NetworkRoute> network_route) {
   RTC_DCHECK(network_thread_->IsCurrent());
-  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);
-
-    UpdateTransportOverhead();
+  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);
   }
+
+  // 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.
   invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_, [=] {
-    media_channel_->OnNetworkRouteChanged(transport_name, network_route);
+    media_channel_->OnNetworkRouteChanged(transport_name_, new_route);
   });
 }
 
@@ -915,9 +908,8 @@
 
   if (!ret) {
     RTC_LOG(LS_WARNING) << "DTLS-SRTP key installation failed";
-  } else {
-    UpdateTransportOverhead();
   }
+
   return ret;
 }
 
@@ -1021,6 +1013,7 @@
   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_);
@@ -1031,6 +1024,8 @@
         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.";
   }
 }
@@ -1160,7 +1155,7 @@
         // the RTCP transport.
         std::string debug_name =
             transport_name_.empty()
-                ? rtp_transport_->rtp_packet_transport()->debug_name()
+                ? rtp_transport_->rtp_packet_transport()->transport_name()
                 : transport_name_;
         RTC_LOG(LS_INFO) << "Enabling rtcp-mux for " << content_name()
                          << "; no longer need RTCP transport for "
@@ -1679,47 +1674,6 @@
       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.
diff --git a/pc/channel.h b/pc/channel.h
index ec13f07..352fda4 100644
--- a/pc/channel.h
+++ b/pc/channel.h
@@ -243,11 +243,7 @@
 
   void OnDtlsState(DtlsTransportInternal* transport, DtlsTransportState state);
 
-  void OnSelectedCandidatePairChanged(
-      IceTransportInternal* ice_transport,
-      CandidatePairInterface* selected_candidate_pair,
-      int last_sent_packet_id,
-      bool ready_to_send);
+  void OnNetworkRouteChanged(rtc::Optional<rtc::NetworkRoute> network_route);
 
   bool PacketIsRtcp(const rtc::PacketTransportInternal* transport,
                     const char* data,
@@ -363,8 +359,6 @@
   void SignalSentPacket_w(const rtc::SentPacket& sent_packet);
   bool IsReadyToSendMedia_n() const;
   void CacheRtpAbsSendTimeHeaderExtension_n(int rtp_abs_sendtime_extn_id);
-  int GetTransportOverheadPerPacket() const;
-  void UpdateTransportOverhead();
   // Wraps the existing RtpTransport in an SrtpTransport.
   void EnableSrtpTransport_n();
 
diff --git a/pc/channel_unittest.cc b/pc/channel_unittest.cc
index 5736bb6..36d7b00 100644
--- a/pc/channel_unittest.cc
+++ b/pc/channel_unittest.cc
@@ -1202,6 +1202,8 @@
     static constexpr uint16_t kLocalNetId = 1;
     static constexpr uint16_t kRemoteNetId = 2;
     static constexpr int kLastPacketId = 100;
+    // Ipv4(20) + UDP(8).
+    static constexpr int kTransportOverheadPerPacket = 28;
 
     CreateChannels(0, 0);
 
@@ -1209,12 +1211,17 @@
         static_cast<typename T::MediaChannel*>(channel1_->media_channel());
     ASSERT_TRUE(media_channel1);
 
+    // Need to wait for the threads before calling
+    // |set_num_network_route_changes| because the network route would be set
+    // when creating the channel.
+    WaitForThreads();
     media_channel1->set_num_network_route_changes(0);
     network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
+      rtc::NetworkRoute network_route;
       // The transport channel becomes disconnected.
-      fake_rtp_dtls_transport1_->ice_transport()
-          ->SignalSelectedCandidatePairChanged(
-              fake_rtp_dtls_transport1_->ice_transport(), nullptr, -1, false);
+      fake_rtp_dtls_transport1_->ice_transport()->SignalNetworkRouteChanged(
+
+          rtc::Optional<rtc::NetworkRoute>(network_route));
     });
     WaitForThreads();
     EXPECT_EQ(1, media_channel1->num_network_route_changes());
@@ -1222,15 +1229,16 @@
     media_channel1->set_num_network_route_changes(0);
 
     network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
+      rtc::NetworkRoute network_route;
+      network_route.connected = true;
+      network_route.local_network_id = kLocalNetId;
+      network_route.remote_network_id = kRemoteNetId;
+      network_route.last_sent_packet_id = kLastPacketId;
+      network_route.packet_overhead = kTransportOverheadPerPacket;
       // The transport channel becomes connected.
-      rtc::SocketAddress local_address("192.168.1.1", 1000 /* port number */);
-      rtc::SocketAddress remote_address("192.168.1.2", 2000 /* port number */);
-      auto candidate_pair = cricket::FakeCandidatePair::Create(
-          local_address, kLocalNetId, remote_address, kRemoteNetId);
-      fake_rtp_dtls_transport1_->ice_transport()
-          ->SignalSelectedCandidatePairChanged(
-              fake_rtp_dtls_transport1_->ice_transport(), candidate_pair.get(),
-              kLastPacketId, true);
+      fake_rtp_dtls_transport1_->ice_transport()->SignalNetworkRouteChanged(
+
+          rtc::Optional<rtc::NetworkRoute>(network_route));
     });
     WaitForThreads();
     EXPECT_EQ(1, media_channel1->num_network_route_changes());
@@ -1239,7 +1247,6 @@
     EXPECT_EQ(expected_network_route, media_channel1->last_network_route());
     EXPECT_EQ(kLastPacketId,
               media_channel1->last_network_route().last_sent_packet_id);
-    constexpr int kTransportOverheadPerPacket = 28;  // Ipv4(20) + UDP(8).
     EXPECT_EQ(kTransportOverheadPerPacket,
               media_channel1->transport_overhead_per_packet());
   }
diff --git a/pc/rtptransport.cc b/pc/rtptransport.cc
index 1701c4d..d2604f9 100644
--- a/pc/rtptransport.cc
+++ b/pc/rtptransport.cc
@@ -11,6 +11,7 @@
 #include "pc/rtptransport.h"
 
 #include "media/base/rtputils.h"
+#include "p2p/base/p2pconstants.h"
 #include "p2p/base/packettransportinterface.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/copyonwritebuffer.h"
@@ -31,15 +32,22 @@
   if (rtp_packet_transport_) {
     rtp_packet_transport_->SignalReadyToSend.disconnect(this);
     rtp_packet_transport_->SignalReadPacket.disconnect(this);
+    rtp_packet_transport_->SignalNetworkRouteChanged.disconnect(this);
+    // Reset the network route of the old transport.
+    SignalNetworkRouteChanged(rtc::Optional<rtc::NetworkRoute>());
   }
   if (new_packet_transport) {
     new_packet_transport->SignalReadyToSend.connect(
         this, &RtpTransport::OnReadyToSend);
     new_packet_transport->SignalReadPacket.connect(this,
                                                    &RtpTransport::OnReadPacket);
+    new_packet_transport->SignalNetworkRouteChanged.connect(
+        this, &RtpTransport::OnNetworkRouteChange);
+    // Set the network route for the new transport.
+    SignalNetworkRouteChanged(new_packet_transport->network_route());
   }
-  rtp_packet_transport_ = new_packet_transport;
 
+  rtp_packet_transport_ = new_packet_transport;
   // Assumes the transport is ready to send if it is writable. If we are wrong,
   // ready to send will be updated the next time we try to send.
   SetReadyToSend(false,
@@ -54,12 +62,19 @@
   if (rtcp_packet_transport_) {
     rtcp_packet_transport_->SignalReadyToSend.disconnect(this);
     rtcp_packet_transport_->SignalReadPacket.disconnect(this);
+    rtcp_packet_transport_->SignalNetworkRouteChanged.disconnect(this);
+    // Reset the network route of the old transport.
+    SignalNetworkRouteChanged(rtc::Optional<rtc::NetworkRoute>());
   }
   if (new_packet_transport) {
     new_packet_transport->SignalReadyToSend.connect(
         this, &RtpTransport::OnReadyToSend);
     new_packet_transport->SignalReadPacket.connect(this,
                                                    &RtpTransport::OnReadPacket);
+    new_packet_transport->SignalNetworkRouteChanged.connect(
+        this, &RtpTransport::OnNetworkRouteChange);
+    // Set the network route for the new transport.
+    SignalNetworkRouteChanged(new_packet_transport->network_route());
   }
   rtcp_packet_transport_ = new_packet_transport;
 
@@ -161,6 +176,11 @@
   SetReadyToSend(transport == rtcp_packet_transport_, true);
 }
 
+void RtpTransport::OnNetworkRouteChange(
+    rtc::Optional<rtc::NetworkRoute> network_route) {
+  SignalNetworkRouteChanged(network_route);
+}
+
 void RtpTransport::SetReadyToSend(bool rtcp, bool ready) {
   if (rtcp) {
     rtcp_ready_to_send_ = ready;
diff --git a/pc/rtptransport.h b/pc/rtptransport.h
index 5e1aa20..34ec1b4 100644
--- a/pc/rtptransport.h
+++ b/pc/rtptransport.h
@@ -11,6 +11,8 @@
 #ifndef PC_RTPTRANSPORT_H_
 #define PC_RTPTRANSPORT_H_
 
+#include <string>
+
 #include "pc/bundlefilter.h"
 #include "pc/rtptransportinternal.h"
 #include "rtc_base/sigslot.h"
@@ -76,6 +78,7 @@
   bool HandlesPacket(const uint8_t* data, size_t len);
 
   void OnReadyToSend(rtc::PacketTransportInternal* transport);
+  void OnNetworkRouteChange(rtc::Optional<rtc::NetworkRoute> network_route);
 
   // Updates "ready to send" for an individual channel and fires
   // SignalReadyToSend.
diff --git a/pc/rtptransport_unittest.cc b/pc/rtptransport_unittest.cc
index 1e1657d..d6eb336 100644
--- a/pc/rtptransport_unittest.cc
+++ b/pc/rtptransport_unittest.cc
@@ -19,6 +19,10 @@
 
 constexpr bool kMuxDisabled = false;
 constexpr bool kMuxEnabled = true;
+constexpr uint16_t kLocalNetId = 1;
+constexpr uint16_t kRemoteNetId = 2;
+constexpr int kLastPacketId = 100;
+constexpr int kTransportOverheadPerPacket = 28;  // Ipv4(20) + UDP(8).
 
 TEST(RtpTransportTest, SetRtcpParametersCantDisableRtcpMux) {
   RtpTransport transport(kMuxDisabled);
@@ -56,12 +60,21 @@
  public:
   explicit SignalObserver(RtpTransport* transport) {
     transport->SignalReadyToSend.connect(this, &SignalObserver::OnReadyToSend);
+    transport->SignalNetworkRouteChanged.connect(
+        this, &SignalObserver::OnNetworkRouteChanged);
   }
+
   bool ready() const { return ready_; }
   void OnReadyToSend(bool ready) { ready_ = ready; }
 
+  rtc::Optional<rtc::NetworkRoute> network_route() { return network_route_; }
+  void OnNetworkRouteChanged(rtc::Optional<rtc::NetworkRoute> network_route) {
+    network_route_ = network_route;
+  }
+
  private:
   bool ready_ = false;
+  rtc::Optional<rtc::NetworkRoute> network_route_;
 };
 
 TEST(RtpTransportTest, SettingRtcpAndRtpSignalsReady) {
@@ -128,6 +141,61 @@
   EXPECT_TRUE(observer.ready());
 }
 
+// Tests the SignalNetworkRoute is fired when setting a packet transport.
+TEST(RtpTransportTest, SetRtpTransportWithNetworkRouteChanged) {
+  RtpTransport transport(kMuxDisabled);
+  SignalObserver observer(&transport);
+  rtc::FakePacketTransport fake_rtp("fake_rtp");
+
+  EXPECT_FALSE(observer.network_route());
+
+  rtc::NetworkRoute network_route;
+  // Set a non-null RTP transport with a new network route.
+  network_route.connected = true;
+  network_route.local_network_id = kLocalNetId;
+  network_route.remote_network_id = kRemoteNetId;
+  network_route.last_sent_packet_id = kLastPacketId;
+  network_route.packet_overhead = kTransportOverheadPerPacket;
+  fake_rtp.SetNetworkRoute(rtc::Optional<rtc::NetworkRoute>(network_route));
+  transport.SetRtpPacketTransport(&fake_rtp);
+  ASSERT_TRUE(observer.network_route());
+  EXPECT_EQ(network_route, *(observer.network_route()));
+  EXPECT_EQ(kTransportOverheadPerPacket,
+            observer.network_route()->packet_overhead);
+  EXPECT_EQ(kLastPacketId, observer.network_route()->last_sent_packet_id);
+
+  // Set a null RTP transport.
+  transport.SetRtpPacketTransport(nullptr);
+  EXPECT_FALSE(observer.network_route());
+}
+
+TEST(RtpTransportTest, SetRtcpTransportWithNetworkRouteChanged) {
+  RtpTransport transport(kMuxDisabled);
+  SignalObserver observer(&transport);
+  rtc::FakePacketTransport fake_rtcp("fake_rtcp");
+
+  EXPECT_FALSE(observer.network_route());
+
+  rtc::NetworkRoute network_route;
+  // Set a non-null RTCP transport with a new network route.
+  network_route.connected = true;
+  network_route.local_network_id = kLocalNetId;
+  network_route.remote_network_id = kRemoteNetId;
+  network_route.last_sent_packet_id = kLastPacketId;
+  network_route.packet_overhead = kTransportOverheadPerPacket;
+  fake_rtcp.SetNetworkRoute(rtc::Optional<rtc::NetworkRoute>(network_route));
+  transport.SetRtcpPacketTransport(&fake_rtcp);
+  ASSERT_TRUE(observer.network_route());
+  EXPECT_EQ(network_route, *(observer.network_route()));
+  EXPECT_EQ(kTransportOverheadPerPacket,
+            observer.network_route()->packet_overhead);
+  EXPECT_EQ(kLastPacketId, observer.network_route()->last_sent_packet_id);
+
+  // Set a null RTCP transport.
+  transport.SetRtcpPacketTransport(nullptr);
+  EXPECT_FALSE(observer.network_route());
+}
+
 class SignalCounter : public sigslot::has_slots<> {
  public:
   explicit SignalCounter(RtpTransport* transport) {
diff --git a/pc/rtptransportinternal.h b/pc/rtptransportinternal.h
index e589619..04d2ef3 100644
--- a/pc/rtptransportinternal.h
+++ b/pc/rtptransportinternal.h
@@ -11,7 +11,11 @@
 #ifndef PC_RTPTRANSPORTINTERNAL_H_
 #define PC_RTPTRANSPORTINTERNAL_H_
 
+#include <string>
+
 #include "api/ortc/rtptransportinterface.h"
+#include "p2p/base/icetransportinternal.h"
+#include "rtc_base/networkroute.h"
 #include "rtc_base/sigslot.h"
 
 namespace rtc {
@@ -52,6 +56,10 @@
   sigslot::signal3<bool, rtc::CopyOnWriteBuffer*, const rtc::PacketTime&>
       SignalPacketReceived;
 
+  // Called whenever the network route of the P2P layer transport changes.
+  // The argument is an optional network route.
+  sigslot::signal1<rtc::Optional<rtc::NetworkRoute>> SignalNetworkRouteChanged;
+
   virtual bool IsWritable(bool rtcp) const = 0;
 
   virtual bool SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
diff --git a/pc/srtptransport.cc b/pc/srtptransport.cc
index 1343fd0..bb42ad4 100644
--- a/pc/srtptransport.cc
+++ b/pc/srtptransport.cc
@@ -42,6 +42,8 @@
       this, &SrtpTransport::OnPacketReceived);
   rtp_transport_->SignalReadyToSend.connect(this,
                                             &SrtpTransport::OnReadyToSend);
+  rtp_transport_->SignalNetworkRouteChanged.connect(
+      this, &SrtpTransport::OnNetworkRouteChanged);
 }
 
 bool SrtpTransport::SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
@@ -170,6 +172,20 @@
   SignalPacketReceived(rtcp, packet, packet_time);
 }
 
+void SrtpTransport::OnNetworkRouteChanged(
+
+    rtc::Optional<rtc::NetworkRoute> network_route) {
+  // Only append the SRTP overhead when there is a selected network route.
+  if (network_route) {
+    int srtp_overhead = 0;
+    if (IsActive()) {
+      GetSrtpOverhead(&srtp_overhead);
+    }
+    network_route->packet_overhead += srtp_overhead;
+  }
+  SignalNetworkRouteChanged(network_route);
+}
+
 bool SrtpTransport::SetRtpParams(int send_cs,
                                  const uint8_t* send_key,
                                  int send_key_len,
diff --git a/pc/srtptransport.h b/pc/srtptransport.h
index 13abd6b..919d4b9 100644
--- a/pc/srtptransport.h
+++ b/pc/srtptransport.h
@@ -16,6 +16,7 @@
 #include <utility>
 #include <vector>
 
+#include "p2p/base/icetransportinternal.h"
 #include "pc/rtptransportinternal.h"
 #include "pc/srtpfilter.h"
 #include "pc/srtpsession.h"
@@ -158,8 +159,8 @@
   void OnPacketReceived(bool rtcp,
                         rtc::CopyOnWriteBuffer* packet,
                         const rtc::PacketTime& packet_time);
-
   void OnReadyToSend(bool ready) { SignalReadyToSend(ready); }
+  void OnNetworkRouteChanged(rtc::Optional<rtc::NetworkRoute> network_route);
 
   bool ProtectRtp(void* data, int in_len, int max_len, int* out_len);
 
diff --git a/pc/transportcontroller.cc b/pc/transportcontroller.cc
index 57f90b7..7cf9bbd 100644
--- a/pc/transportcontroller.cc
+++ b/pc/transportcontroller.cc
@@ -761,7 +761,7 @@
 void TransportController::OnChannelWritableState_n(
     rtc::PacketTransportInternal* transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
-  RTC_LOG(LS_INFO) << " TransportChannel " << transport->debug_name()
+  RTC_LOG(LS_INFO) << " Transport " << transport->transport_name()
                    << " writability changed to " << transport->writable()
                    << ".";
   UpdateAggregateStates_n();