Reland: Replaced the SignalSelectedCandidatePairChanged with a new signal.
|packet_overhead| field is added to rtc::NetworkRoute structure.
In PackTransportInternal:
1. network_route() is added which returns the current network route.
2. debug_name() is removed.
3. transport_name() is moved from DtlsTransportInternal and
IceTransportInternal to PacketTransportInternal.
When the selected candidate pair is changed, the P2PTransportChannel
will fire the SignalNetworkRouteChanged instead of
SignalSelectedCandidatePairChanged to upper layers.
The Rtp/SrtpTransport takes the responsibility of calculating the
transport overhead from the BaseChannel so that the BaseChannel
doesn't need to depend on P2P layer transports.
TBR=pthatcher@webrtc.org
Bug: webrtc:7013
Change-Id: If9928b25a7259544c2d9c42048b53ab24292fc67
Reviewed-on: https://webrtc-review.googlesource.com/22767
Reviewed-by: Zhi Huang <zhihuang@webrtc.org>
Commit-Queue: Zhi Huang <zhihuang@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20664}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();
