admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Have BaseChannel take MediaChannel as unique_ptr

Browse Source 
Bug: None
Change-Id: I9a0c67cc364623b7c17824271edfbd782f88dbfb
Reviewed-on: https://webrtc-review.googlesource.com/18300
Commit-Queue: Steve Anton <steveanton@webrtc.org>
Reviewed-by: Peter Thatcher <pthatcher@webrtc.org>
Reviewed-by: Zhi Huang <zhihuang@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20594}
This commit is contained in:
Steve Anton 2017-11-06 15:53:33 -08:00 committed by Commit Bot
parent c9e1560d32
commit 8699a3229f
6 changed files with 199 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
pc/channel.cc
View File

@ -142,7 +142,7 @@ void RtpSendParametersFromMediaDescription(
BaseChannel::BaseChannel(rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
MediaChannel* media_channel,
std::unique_ptr<MediaChannel> media_channel,
const std::string& content_name,
bool rtcp_mux_required,
bool srtp_required)
@ -152,9 +152,9 @@ BaseChannel::BaseChannel(rtc::Thread* worker_thread,
content_name_(content_name),
rtcp_mux_required_(rtcp_mux_required),
srtp_required_(srtp_required),
media_channel_(media_channel),
media_channel_(std::move(media_channel)),
selected_candidate_pair_(nullptr) {
RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
RTC_DCHECK_RUN_ON(worker_thread_);
if (srtp_required) {
auto transport =
rtc::MakeUnique<webrtc::SrtpTransport>(rtcp_mux_required, content_name);
@ -179,7 +179,7 @@ BaseChannel::BaseChannel(rtc::Thread* worker_thread,
BaseChannel::~BaseChannel() {
TRACE_EVENT0("webrtc", "BaseChannel::~BaseChannel");
RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
RTC_DCHECK_RUN_ON(worker_thread_);
Deinit();
StopConnectionMonitor();
// Eats any outstanding messages or packets.
@ -188,7 +188,7 @@ BaseChannel::~BaseChannel() {
// We must destroy the media channel before the transport channel, otherwise
// the media channel may try to send on the dead transport channel. NULLing
// is not an effective strategy since the sends will come on another thread.
delete media_channel_;
media_channel_.reset();
LOG(LS_INFO) << "Destroyed channel: " << content_name_;
}
@ -217,24 +217,22 @@ void BaseChannel::DisconnectTransportChannels_n() {
network_thread_->Clear(this);
}
bool BaseChannel::Init_w(DtlsTransportInternal* rtp_dtls_transport,
void BaseChannel::Init_w(DtlsTransportInternal* rtp_dtls_transport,
DtlsTransportInternal* rtcp_dtls_transport,
rtc::PacketTransportInternal* rtp_packet_transport,
rtc::PacketTransportInternal* rtcp_packet_transport) {
if (!network_thread_->Invoke<bool>(
RTC_FROM_HERE, Bind(&BaseChannel::InitNetwork_n, this,
rtp_dtls_transport, rtcp_dtls_transport,
rtp_packet_transport, rtcp_packet_transport))) {
return false;
}
RTC_DCHECK_RUN_ON(worker_thread_);
network_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
return InitNetwork_n(rtp_dtls_transport, rtcp_dtls_transport,
rtp_packet_transport, rtcp_packet_transport);
});
// Both RTP and RTCP channels should be set, we can call SetInterface on
// the media channel and it can set network options.
RTC_DCHECK_RUN_ON(worker_thread_);
media_channel_->SetInterface(this);
return true;
}
bool BaseChannel::InitNetwork_n(
void BaseChannel::InitNetwork_n(
DtlsTransportInternal* rtp_dtls_transport,
DtlsTransportInternal* rtcp_dtls_transport,
rtc::PacketTransportInternal* rtp_packet_transport,
@ -246,7 +244,6 @@ bool BaseChannel::InitNetwork_n(
if (rtcp_mux_required_) {
rtcp_mux_filter_.SetActive();
}
return true;
}
void BaseChannel::Deinit() {
@ -615,16 +612,14 @@ void BaseChannel::OnSelectedCandidatePairChanged(
UpdateTransportOverhead();
}
invoker_.AsyncInvoke<void>(
RTC_FROM_HERE, worker_thread_,
Bind(&MediaChannel::OnNetworkRouteChanged, media_channel_, transport_name,
network_route));
invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_, [=] {
media_channel_->OnNetworkRouteChanged(transport_name, network_route);
});
}
void BaseChannel::OnTransportReadyToSend(bool ready) {
invoker_.AsyncInvoke<void>(
RTC_FROM_HERE, worker_thread_,
Bind(&MediaChannel::OnReadyToSend, media_channel_, ready));
invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_,
[=] { media_channel_->OnReadyToSend(ready); });
}
bool BaseChannel::SendPacket(bool rtcp,
@ -1435,19 +1430,18 @@ VoiceChannel::VoiceChannel(rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
MediaEngineInterface* media_engine,
VoiceMediaChannel* media_channel,
std::unique_ptr<VoiceMediaChannel> media_channel,
const std::string& content_name,
bool rtcp_mux_required,
bool srtp_required)
: BaseChannel(worker_thread,
network_thread,
signaling_thread,
media_channel,
std::move(media_channel),
content_name,
rtcp_mux_required,
srtp_required),
media_engine_(media_engine),
received_media_(false) {}
media_engine_(media_engine) {}
VoiceChannel::~VoiceChannel() {
TRACE_EVENT0("webrtc", "VoiceChannel::~VoiceChannel");
@ -1676,7 +1670,7 @@ void BaseChannel::UpdateTransportOverhead() {
if (transport_overhead_per_packet)
invoker_.AsyncInvoke<void>(
RTC_FROM_HERE, worker_thread_,
Bind(&MediaChannel::OnTransportOverheadChanged, media_channel_,
Bind(&MediaChannel::OnTransportOverheadChanged, media_channel_.get(),
transport_overhead_per_packet));
}
@ -1852,14 +1846,14 @@ void VoiceChannel::OnAudioMonitorUpdate(AudioMonitor* monitor,
VideoChannel::VideoChannel(rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
VideoMediaChannel* media_channel,
std::unique_ptr<VideoMediaChannel> media_channel,
const std::string& content_name,
bool rtcp_mux_required,
bool srtp_required)
: BaseChannel(worker_thread,
network_thread,
signaling_thread,
media_channel,
std::move(media_channel),
content_name,
rtcp_mux_required,
srtp_required) {}
@ -2112,14 +2106,14 @@ void VideoChannel::OnMediaMonitorUpdate(
RtpDataChannel::RtpDataChannel(rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
DataMediaChannel* media_channel,
std::unique_ptr<DataMediaChannel> media_channel,
const std::string& content_name,
bool rtcp_mux_required,
bool srtp_required)
: BaseChannel(worker_thread,
network_thread,
signaling_thread,
media_channel,
std::move(media_channel),
content_name,
rtcp_mux_required,
srtp_required) {}
@ -2133,20 +2127,18 @@ RtpDataChannel::~RtpDataChannel() {
Deinit();
}
bool RtpDataChannel::Init_w(
void RtpDataChannel::Init_w(
DtlsTransportInternal* rtp_dtls_transport,
DtlsTransportInternal* rtcp_dtls_transport,
rtc::PacketTransportInternal* rtp_packet_transport,
rtc::PacketTransportInternal* rtcp_packet_transport) {
if (!BaseChannel::Init_w(rtp_dtls_transport, rtcp_dtls_transport,
rtp_packet_transport, rtcp_packet_transport)) {
return false;
}
BaseChannel::Init_w(rtp_dtls_transport, rtcp_dtls_transport,
rtp_packet_transport, rtcp_packet_transport);
media_channel()->SignalDataReceived.connect(this,
&RtpDataChannel::OnDataReceived);
media_channel()->SignalReadyToSend.connect(
this, &RtpDataChannel::OnDataChannelReadyToSend);
return true;
}
bool RtpDataChannel::SendData(const SendDataParams& params,

20
pc/channel.h
View File

@ -80,12 +80,12 @@ class BaseChannel
BaseChannel(rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
MediaChannel* channel,
std::unique_ptr<MediaChannel> media_channel,
const std::string& content_name,
bool rtcp_mux_required,
bool srtp_required);
virtual ~BaseChannel();
bool Init_w(DtlsTransportInternal* rtp_dtls_transport,
void Init_w(DtlsTransportInternal* rtp_dtls_transport,
DtlsTransportInternal* rtcp_dtls_transport,
rtc::PacketTransportInternal* rtp_packet_transport,
rtc::PacketTransportInternal* rtcp_packet_transport);
@ -191,7 +191,7 @@ class BaseChannel
bool HandlesPayloadType(int payload_type) const;
protected:
virtual MediaChannel* media_channel() const { return media_channel_; }
virtual MediaChannel* media_channel() const { return media_channel_.get(); }
void SetTransports_n(DtlsTransportInternal* rtp_dtls_transport,
DtlsTransportInternal* rtcp_dtls_transport,
@ -353,7 +353,7 @@ class BaseChannel
void AddHandledPayloadType(int payload_type);
private:
bool InitNetwork_n(DtlsTransportInternal* rtp_dtls_transport,
void InitNetwork_n(DtlsTransportInternal* rtp_dtls_transport,
DtlsTransportInternal* rtcp_dtls_transport,
rtc::PacketTransportInternal* rtp_packet_transport,
rtc::PacketTransportInternal* rtcp_packet_transport);
@ -400,7 +400,7 @@ class BaseChannel
// MediaChannel related members that should be accessed from the worker
// thread.
MediaChannel* const media_channel_;
std::unique_ptr<MediaChannel> media_channel_;
// Currently the |enabled_| flag is accessed from the signaling thread as
// well, but it can be changed only when signaling thread does a synchronous
// call to the worker thread, so it should be safe.
@ -420,7 +420,7 @@ class VoiceChannel : public BaseChannel {
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
MediaEngineInterface* media_engine,
VoiceMediaChannel* channel,
std::unique_ptr<VoiceMediaChannel> channel,
const std::string& content_name,
bool rtcp_mux_required,
bool srtp_required);
@ -517,7 +517,7 @@ class VoiceChannel : public BaseChannel {
static const int kEarlyMediaTimeout = 1000;
MediaEngineInterface* media_engine_;
bool received_media_;
bool received_media_ = false;
std::unique_ptr<VoiceMediaMonitor> media_monitor_;
std::unique_ptr<AudioMonitor> audio_monitor_;
@ -535,7 +535,7 @@ class VideoChannel : public BaseChannel {
VideoChannel(rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
VideoMediaChannel* channel,
std::unique_ptr<VideoMediaChannel> media_channel,
const std::string& content_name,
bool rtcp_mux_required,
bool srtp_required);
@ -612,12 +612,12 @@ class RtpDataChannel : public BaseChannel {
RtpDataChannel(rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
DataMediaChannel* channel,
std::unique_ptr<DataMediaChannel> channel,
const std::string& content_name,
bool rtcp_mux_required,
bool srtp_required);
~RtpDataChannel();
bool Init_w(DtlsTransportInternal* rtp_dtls_transport,
void Init_w(DtlsTransportInternal* rtp_dtls_transport,
DtlsTransportInternal* rtcp_dtls_transport,
rtc::PacketTransportInternal* rtp_packet_transport,
rtc::PacketTransportInternal* rtcp_packet_transport);

135
pc/channel_unittest.cc
View File

@ -121,12 +121,14 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
}
void CreateChannels(int flags1, int flags2) {
CreateChannels(new typename T::MediaChannel(NULL, typename T::Options()),
new typename T::MediaChannel(NULL, typename T::Options()),
CreateChannels(rtc::MakeUnique<typename T::MediaChannel>(
nullptr, typename T::Options()),
rtc::MakeUnique<typename T::MediaChannel>(
nullptr, typename T::Options()),
flags1, flags2);
}
void CreateChannels(typename T::MediaChannel* ch1,
typename T::MediaChannel* ch2,
void CreateChannels(std::unique_ptr<typename T::MediaChannel> ch1,
std::unique_ptr<typename T::MediaChannel> ch2,
int flags1,
int flags2) {
// Network thread is started in CreateChannels, to allow the test to
@ -142,8 +144,8 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
// channels.
RTC_DCHECK_EQ(flags1 & RAW_PACKET_TRANSPORT, flags2 & RAW_PACKET_TRANSPORT);
rtc::Thread* worker_thread = rtc::Thread::Current();
media_channel1_ = ch1;
media_channel2_ = ch2;
media_channel1_ = ch1.get();
media_channel2_ = ch2.get();
rtc::PacketTransportInternal* rtp1 = nullptr;
rtc::PacketTransportInternal* rtcp1 = nullptr;
rtc::PacketTransportInternal* rtp2 = nullptr;
@ -240,14 +242,14 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
}
}
}
channel1_.reset(
CreateChannel(worker_thread, network_thread_, &media_engine_, ch1,
fake_rtp_dtls_transport1_.get(),
fake_rtcp_dtls_transport1_.get(), rtp1, rtcp1, flags1));
channel2_.reset(
CreateChannel(worker_thread, network_thread_, &media_engine_, ch2,
fake_rtp_dtls_transport2_.get(),
fake_rtcp_dtls_transport2_.get(), rtp2, rtcp2, flags2));
channel1_ =
CreateChannel(worker_thread, network_thread_, &media_engine_,
std::move(ch1), fake_rtp_dtls_transport1_.get(),
fake_rtcp_dtls_transport1_.get(), rtp1, rtcp1, flags1);
channel2_ =
CreateChannel(worker_thread, network_thread_, &media_engine_,
std::move(ch2), fake_rtp_dtls_transport2_.get(),
fake_rtcp_dtls_transport2_.get(), rtp2, rtcp2, flags2);
channel1_->SignalMediaMonitor.connect(this,
&ChannelTest<T>::OnMediaMonitor1);
channel2_->SignalMediaMonitor.connect(this,
@ -281,30 +283,26 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
AddLegacyStreamInContent(kSsrc2, flags2, &remote_media_content2_);
}
}
typename T::Channel* CreateChannel(
std::unique_ptr<typename T::Channel> CreateChannel(
rtc::Thread* worker_thread,
rtc::Thread* network_thread,
cricket::MediaEngineInterface* engine,
typename T::MediaChannel* ch,
std::unique_ptr<typename T::MediaChannel> ch,
cricket::DtlsTransportInternal* fake_rtp_dtls_transport,
cricket::DtlsTransportInternal* fake_rtcp_dtls_transport,
rtc::PacketTransportInternal* fake_rtp_packet_transport,
rtc::PacketTransportInternal* fake_rtcp_packet_transport,
int flags) {
rtc::Thread* signaling_thread = rtc::Thread::Current();
typename T::Channel* channel = new typename T::Channel(
worker_thread, network_thread, signaling_thread, engine, ch,
auto channel = rtc::MakeUnique<typename T::Channel>(
worker_thread, network_thread, signaling_thread, engine, std::move(ch),
cricket::CN_AUDIO, (flags & RTCP_MUX_REQUIRED) != 0,
(flags & SECURE) != 0);
if (!channel->NeedsRtcpTransport()) {
fake_rtcp_dtls_transport = nullptr;
}
if (!channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
fake_rtp_packet_transport,
fake_rtcp_packet_transport)) {
delete channel;
channel = NULL;
}
channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
fake_rtp_packet_transport, fake_rtcp_packet_transport);
return channel;
}
@ -1280,8 +1278,8 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
T::MediaChannel::SendRtcp(kRtcpReport, sizeof(kRtcpReport));
}
};
CreateChannels(new LastWordMediaChannel(), new LastWordMediaChannel(),
RTCP_MUX, RTCP_MUX);
CreateChannels(rtc::MakeUnique<LastWordMediaChannel>(),
rtc::MakeUnique<LastWordMediaChannel>(), RTCP_MUX, RTCP_MUX);
EXPECT_TRUE(SendInitiate());
EXPECT_TRUE(SendAccept());
EXPECT_TRUE(Terminate());
@ -2207,28 +2205,26 @@ class VoiceChannelWithEncryptedRtpHeaderExtensionsDoubleThreadTest
// override to add NULL parameter
template <>
cricket::VideoChannel* ChannelTest<VideoTraits>::CreateChannel(
std::unique_ptr<cricket::VideoChannel> ChannelTest<VideoTraits>::CreateChannel(
rtc::Thread* worker_thread,
rtc::Thread* network_thread,
cricket::MediaEngineInterface* engine,
cricket::FakeVideoMediaChannel* ch,
std::unique_ptr<cricket::FakeVideoMediaChannel> ch,
cricket::DtlsTransportInternal* fake_rtp_dtls_transport,
cricket::DtlsTransportInternal* fake_rtcp_dtls_transport,
rtc::PacketTransportInternal* fake_rtp_packet_transport,
rtc::PacketTransportInternal* fake_rtcp_packet_transport,
int flags) {
rtc::Thread* signaling_thread = rtc::Thread::Current();
cricket::VideoChannel* channel = new cricket::VideoChannel(
worker_thread, network_thread, signaling_thread, ch, cricket::CN_VIDEO,
(flags & RTCP_MUX_REQUIRED) != 0, (flags & SECURE) != 0);
auto channel = rtc::MakeUnique<cricket::VideoChannel>(
worker_thread, network_thread, signaling_thread, std::move(ch),
cricket::CN_VIDEO, (flags & RTCP_MUX_REQUIRED) != 0,
(flags & SECURE) != 0);
if (!channel->NeedsRtcpTransport()) {
fake_rtcp_dtls_transport = nullptr;
}
if (!channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
fake_rtp_packet_transport, fake_rtcp_packet_transport)) {
delete channel;
channel = NULL;
}
channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
fake_rtp_packet_transport, fake_rtcp_packet_transport);
return channel;
}
@ -3501,28 +3497,26 @@ class RtpDataChannelDoubleThreadTest : public ChannelTest<DataTraits> {
// Override to avoid engine channel parameter.
template <>
cricket::RtpDataChannel* ChannelTest<DataTraits>::CreateChannel(
std::unique_ptr<cricket::RtpDataChannel> ChannelTest<DataTraits>::CreateChannel(
rtc::Thread* worker_thread,
rtc::Thread* network_thread,
cricket::MediaEngineInterface* engine,
cricket::FakeDataMediaChannel* ch,
std::unique_ptr<cricket::FakeDataMediaChannel> ch,
cricket::DtlsTransportInternal* fake_rtp_dtls_transport,
cricket::DtlsTransportInternal* fake_rtcp_dtls_transport,
rtc::PacketTransportInternal* fake_rtp_packet_transport,
rtc::PacketTransportInternal* fake_rtcp_packet_transport,
int flags) {
rtc::Thread* signaling_thread = rtc::Thread::Current();
cricket::RtpDataChannel* channel = new cricket::RtpDataChannel(
worker_thread, network_thread, signaling_thread, ch, cricket::CN_DATA,
(flags & RTCP_MUX_REQUIRED) != 0, (flags & SECURE) != 0);
auto channel = rtc::MakeUnique<cricket::RtpDataChannel>(
worker_thread, network_thread, signaling_thread, std::move(ch),
cricket::CN_DATA, (flags & RTCP_MUX_REQUIRED) != 0,
(flags & SECURE) != 0);
if (!channel->NeedsRtcpTransport()) {
fake_rtcp_dtls_transport = nullptr;
}
if (!channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
fake_rtp_packet_transport, fake_rtcp_packet_transport)) {
delete channel;
channel = NULL;
}
channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
fake_rtp_packet_transport, fake_rtcp_packet_transport);
return channel;
}
@ -3847,16 +3841,16 @@ class BaseChannelDeathTest : public testing::Test {
: fake_rtp_dtls_transport_("foo", cricket::ICE_CANDIDATE_COMPONENT_RTP),
fake_rtcp_dtls_transport_("foo", cricket::ICE_CANDIDATE_COMPONENT_RTCP),
// RTCP mux not required, SRTP required.
voice_channel_(
rtc::Thread::Current(),
rtc::Thread::Current(),
rtc::Thread::Current(),
&fake_media_engine_,
new cricket::FakeVoiceMediaChannel(nullptr,
cricket::AudioOptions()),
cricket::CN_AUDIO,
false,
true) {}
voice_channel_(rtc::Thread::Current(),
rtc::Thread::Current(),
rtc::Thread::Current(),
&fake_media_engine_,
rtc::MakeUnique<cricket::FakeVoiceMediaChannel>(
nullptr,
cricket::AudioOptions()),
cricket::CN_AUDIO,
false,
true) {}
protected:
cricket::FakeMediaEngine fake_media_engine_;
@ -3866,27 +3860,24 @@ class BaseChannelDeathTest : public testing::Test {
};
TEST_F(BaseChannelDeathTest, SetTransportsWithNullRtpTransport) {
ASSERT_TRUE(voice_channel_.Init_w(
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_));
voice_channel_.Init_w(&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_);
cricket::FakeDtlsTransport new_rtcp_transport(
"bar", cricket::ICE_CANDIDATE_COMPONENT_RTCP);
EXPECT_DEATH(voice_channel_.SetTransports(nullptr, &new_rtcp_transport), "");
}
TEST_F(BaseChannelDeathTest, SetTransportsWithMissingRtcpTransport) {
ASSERT_TRUE(voice_channel_.Init_w(
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_));
voice_channel_.Init_w(&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_);
cricket::FakeDtlsTransport new_rtp_transport(
"bar", cricket::ICE_CANDIDATE_COMPONENT_RTP);
EXPECT_DEATH(voice_channel_.SetTransports(&new_rtp_transport, nullptr), "");
}
TEST_F(BaseChannelDeathTest, SetTransportsWithUnneededRtcpTransport) {
ASSERT_TRUE(voice_channel_.Init_w(
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_));
voice_channel_.Init_w(&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_);
// Activate RTCP muxing, simulating offer/answer negotiation.
cricket::AudioContentDescription content;
content.set_rtcp_mux(true);
@ -3905,9 +3896,8 @@ TEST_F(BaseChannelDeathTest, SetTransportsWithUnneededRtcpTransport) {
// This test will probably go away if/when we move the transport name out of
// the transport classes and into their parent classes.
TEST_F(BaseChannelDeathTest, SetTransportsWithMismatchingTransportNames) {
ASSERT_TRUE(voice_channel_.Init_w(
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_));
voice_channel_.Init_w(&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_);
cricket::FakeDtlsTransport new_rtp_transport(
"bar", cricket::ICE_CANDIDATE_COMPONENT_RTP);
cricket::FakeDtlsTransport new_rtcp_transport(
@ -3920,9 +3910,8 @@ TEST_F(BaseChannelDeathTest, SetTransportsWithMismatchingTransportNames) {
// Not expected to support going from DtlsTransportInternal to
// PacketTransportInternal.
TEST_F(BaseChannelDeathTest, SetTransportsDtlsToNonDtls) {
ASSERT_TRUE(voice_channel_.Init_w(
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_));
voice_channel_.Init_w(&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_);
EXPECT_DEATH(
voice_channel_.SetTransports(
static_cast<rtc::PacketTransportInternal*>(&fake_rtp_dtls_transport_),
@ -3934,8 +3923,8 @@ TEST_F(BaseChannelDeathTest, SetTransportsDtlsToNonDtls) {
// Not expected to support going from PacketTransportInternal to
// DtlsTransportInternal.
TEST_F(BaseChannelDeathTest, SetTransportsNonDtlsToDtls) {
ASSERT_TRUE(voice_channel_.Init_w(nullptr, nullptr, &fake_rtp_dtls_transport_,
&fake_rtcp_dtls_transport_));
voice_channel_.Init_w(nullptr, nullptr, &fake_rtp_dtls_transport_,
&fake_rtcp_dtls_transport_);
EXPECT_DEATH(voice_channel_.SetTransports(&fake_rtp_dtls_transport_,
&fake_rtp_dtls_transport_),
"");

33
pc/channelmanager.cc
View File

@ -210,12 +210,10 @@ VoiceChannel* ChannelManager::CreateVoiceChannel_w(
auto voice_channel = rtc::MakeUnique<VoiceChannel>(
worker_thread_, network_thread_, signaling_thread, media_engine_.get(),
media_channel, content_name, rtcp_packet_transport == nullptr,
srtp_required);
if (!voice_channel->Init_w(rtp_dtls_transport, rtcp_dtls_transport,
rtp_packet_transport, rtcp_packet_transport)) {
return nullptr;
}
rtc::WrapUnique(media_channel), content_name,
rtcp_packet_transport == nullptr, srtp_required);
voice_channel->Init_w(rtp_dtls_transport, rtcp_dtls_transport,
rtp_packet_transport, rtcp_packet_transport);
VoiceChannel* voice_channel_ptr = voice_channel.get();
voice_channels_.push_back(std::move(voice_channel));
@ -302,12 +300,11 @@ VideoChannel* ChannelManager::CreateVideoChannel_w(
}
auto video_channel = rtc::MakeUnique<VideoChannel>(
worker_thread_, network_thread_, signaling_thread, media_channel,
content_name, rtcp_packet_transport == nullptr, srtp_required);
if (!video_channel->Init_w(rtp_dtls_transport, rtcp_dtls_transport,
rtp_packet_transport, rtcp_packet_transport)) {
return nullptr;
}
worker_thread_, network_thread_, signaling_thread,
rtc::WrapUnique(media_channel), content_name,
rtcp_packet_transport == nullptr, srtp_required);
video_channel->Init_w(rtp_dtls_transport, rtcp_dtls_transport,
rtp_packet_transport, rtcp_packet_transport);
VideoChannel* video_channel_ptr = video_channel.get();
video_channels_.push_back(std::move(video_channel));
@ -363,13 +360,11 @@ RtpDataChannel* ChannelManager::CreateRtpDataChannel(
}
auto data_channel = rtc::MakeUnique<RtpDataChannel>(
worker_thread_, network_thread_, signaling_thread, media_channel,
content_name, rtcp_transport == nullptr, srtp_required);
if (!data_channel->Init_w(rtp_transport, rtcp_transport, rtp_transport,
rtcp_transport)) {
LOG(LS_WARNING) << "Failed to init data channel.";
return nullptr;
}
worker_thread_, network_thread_, signaling_thread,
rtc::WrapUnique(media_channel), content_name, rtcp_transport == nullptr,
srtp_required);
data_channel->Init_w(rtp_transport, rtcp_transport, rtp_transport,
rtcp_transport);
RtpDataChannel* data_channel_ptr = data_channel.get();
data_channels_.push_back(std::move(data_channel));

58
pc/rtcstatscollector_unittest.cc
View File

@ -454,20 +454,21 @@ class RTCStatsCollectorTestHelper : public SetSessionDescriptionObserver {
EXPECT_CALL(pc_, GetSenders()).WillRepeatedly(Return(rtp_senders_));
EXPECT_CALL(pc_, GetReceivers()).WillRepeatedly(Return(rtp_receivers_));
MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel();
auto* voice_media_channel = new MockVoiceMediaChannel();
voice_channel_.reset(new cricket::VoiceChannel(
worker_thread_, network_thread_, nullptr, media_engine_,
voice_media_channel, "VoiceContentName", kDefaultRtcpMuxRequired,
kDefaultSrtpRequired));
rtc::WrapUnique(voice_media_channel), "VoiceContentName",
kDefaultRtcpMuxRequired, kDefaultSrtpRequired));
EXPECT_CALL(pc_, voice_channel())
.WillRepeatedly(Return(voice_channel_.get()));
EXPECT_CALL(*voice_media_channel, GetStats(_))
.WillOnce(DoAll(SetArgPointee<0>(*voice_media_info_), Return(true)));
MockVideoMediaChannel* video_media_channel = new MockVideoMediaChannel();
auto* video_media_channel = new MockVideoMediaChannel();
video_channel_.reset(new cricket::VideoChannel(
worker_thread_, network_thread_, nullptr, video_media_channel,
"VideoContentName", kDefaultRtcpMuxRequired, kDefaultSrtpRequired));
worker_thread_, network_thread_, nullptr,
rtc::WrapUnique(video_media_channel), "VideoContentName",
kDefaultRtcpMuxRequired, kDefaultSrtpRequired));
EXPECT_CALL(pc_, video_channel())
.WillRepeatedly(Return(video_channel_.get()));
EXPECT_CALL(*video_media_channel, GetStats(_))
@ -737,17 +738,18 @@ TEST_F(RTCStatsCollectorTest, CollectRTCCertificateStatsSingle) {
}
TEST_F(RTCStatsCollectorTest, CollectRTCCodecStats) {
MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel();
auto* voice_media_channel = new MockVoiceMediaChannel();
cricket::VoiceChannel voice_channel(
test_->worker_thread(), test_->network_thread(),
test_->signaling_thread(), test_->media_engine(), voice_media_channel,
"VoiceContentName", kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
test_->signaling_thread(), test_->media_engine(),
rtc::WrapUnique(voice_media_channel), "VoiceContentName",
kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
MockVideoMediaChannel* video_media_channel = new MockVideoMediaChannel();
auto* video_media_channel = new MockVideoMediaChannel();
cricket::VideoChannel video_channel(
test_->worker_thread(), test_->network_thread(),
test_->signaling_thread(), video_media_channel, "VideoContentName",
kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
test_->signaling_thread(), rtc::WrapUnique(video_media_channel),
"VideoContentName", kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
// Audio
cricket::VoiceMediaInfo voice_media_info;
@ -1210,11 +1212,11 @@ TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidateStats) {
}
TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidatePairStats) {
MockVideoMediaChannel* video_media_channel = new MockVideoMediaChannel();
auto* video_media_channel = new MockVideoMediaChannel();
cricket::VideoChannel video_channel(
test_->worker_thread(), test_->network_thread(),
test_->signaling_thread(), video_media_channel, "VideoContentName",
kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
test_->signaling_thread(), rtc::WrapUnique(video_media_channel),
"VideoContentName", kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
std::unique_ptr<cricket::Candidate> local_candidate = CreateFakeCandidate(
"42.42.42.42", 42, "protocol", cricket::LOCAL_PORT_TYPE, 42);
@ -1804,11 +1806,12 @@ TEST_F(RTCStatsCollectorTest,
}
TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Audio) {
MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel();
auto* voice_media_channel = new MockVoiceMediaChannel();
cricket::VoiceChannel voice_channel(
test_->worker_thread(), test_->network_thread(),
test_->signaling_thread(), test_->media_engine(), voice_media_channel,
"VoiceContentName", kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
test_->signaling_thread(), test_->media_engine(),
rtc::WrapUnique(voice_media_channel), "VoiceContentName",
kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
test_->SetupRemoteTrackAndReceiver(
cricket::MEDIA_TYPE_AUDIO, "RemoteAudioTrackID", 1);
@ -1883,11 +1886,11 @@ TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Audio) {
}
TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Video) {
MockVideoMediaChannel* video_media_channel = new MockVideoMediaChannel();
auto* video_media_channel = new MockVideoMediaChannel();
cricket::VideoChannel video_channel(
test_->worker_thread(), test_->network_thread(),
test_->signaling_thread(), video_media_channel, "VideoContentName",
kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
test_->signaling_thread(), rtc::WrapUnique(video_media_channel),
"VideoContentName", kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
test_->SetupRemoteTrackAndReceiver(
cricket::MEDIA_TYPE_VIDEO, "RemoteVideoTrackID", 1);
@ -1984,11 +1987,12 @@ TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Video) {
}
TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Audio) {
MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel();
auto* voice_media_channel = new MockVoiceMediaChannel();
cricket::VoiceChannel voice_channel(
test_->worker_thread(), test_->network_thread(),
test_->signaling_thread(), test_->media_engine(), voice_media_channel,
"VoiceContentName", kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
test_->signaling_thread(), test_->media_engine(),
rtc::WrapUnique(voice_media_channel), "VoiceContentName",
kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
test_->SetupLocalTrackAndSender(
cricket::MEDIA_TYPE_AUDIO, "LocalAudioTrackID", 1);
@ -2061,11 +2065,11 @@ TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Audio) {
}
TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Video) {
MockVideoMediaChannel* video_media_channel = new MockVideoMediaChannel();
auto* video_media_channel = new MockVideoMediaChannel();
cricket::VideoChannel video_channel(
test_->worker_thread(), test_->network_thread(),
test_->signaling_thread(), video_media_channel, "VideoContentName",
kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
test_->signaling_thread(), rtc::WrapUnique(video_media_channel),
"VideoContentName", kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
test_->SetupLocalTrackAndSender(
cricket::MEDIA_TYPE_VIDEO, "LocalVideoTrackID", 1);

97
pc/statscollector_unittest.cc
View File

@ -926,9 +926,9 @@ TEST_F(StatsCollectorTest, BytesCounterHandles64Bits) {
new SessionStats(session_stats_));
}));
MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
auto* media_channel = new MockVideoMediaChannel();
cricket::VideoChannel video_channel(
worker_thread_, network_thread_, nullptr, media_channel,
worker_thread_, network_thread_, nullptr, rtc::WrapUnique(media_channel),
kVideoChannelName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
StatsReports reports; // returned values.
cricket::VideoSenderInfo video_sender_info;
@ -973,10 +973,11 @@ TEST_F(StatsCollectorTest, AudioBandwidthEstimationInfoIsReported) {
return std::unique_ptr<SessionStats>(new SessionStats(session_stats_));
}));
MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
auto* media_channel = new MockVoiceMediaChannel();
cricket::VoiceChannel voice_channel(
worker_thread_, network_thread_, nullptr, nullptr, media_channel,
kAudioChannelName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
worker_thread_, network_thread_, nullptr, nullptr,
rtc::WrapUnique(media_channel), kAudioChannelName,
kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
StatsReports reports; // returned values.
cricket::VoiceSenderInfo voice_sender_info;
@ -1040,9 +1041,9 @@ TEST_F(StatsCollectorTest, VideoBandwidthEstimationInfoIsReported) {
new SessionStats(session_stats_));
}));
MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
auto* media_channel = new MockVideoMediaChannel();
cricket::VideoChannel video_channel(
worker_thread_, network_thread_, nullptr, media_channel,
worker_thread_, network_thread_, nullptr, rtc::WrapUnique(media_channel),
kVideoChannelName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
StatsReports reports; // returned values.
@ -1125,10 +1126,10 @@ TEST_F(StatsCollectorTest, OnlyOneSessionObjectExists) {
TEST_F(StatsCollectorTest, TrackObjectExistsWithoutUpdateStats) {
StatsCollectorForTest stats(&pc_);
MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
auto* media_channel = new MockVideoMediaChannel();
cricket::VideoChannel video_channel(
worker_thread_, network_thread_, nullptr, media_channel, "video",
kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
worker_thread_, network_thread_, nullptr, rtc::WrapUnique(media_channel),
"video", kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
AddOutgoingVideoTrackStats();
stats.AddStream(stream_);
@ -1163,9 +1164,9 @@ TEST_F(StatsCollectorTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
new SessionStats(session_stats_));
}));
MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
auto* media_channel = new MockVideoMediaChannel();
cricket::VideoChannel video_channel(
worker_thread_, network_thread_, nullptr, media_channel,
worker_thread_, network_thread_, nullptr, rtc::WrapUnique(media_channel),
kVideoChannelName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
AddOutgoingVideoTrackStats();
stats.AddStream(stream_);
@ -1229,12 +1230,12 @@ TEST_F(StatsCollectorTest, TransportObjectLinkedFromSsrcObject) {
EXPECT_CALL(pc_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
.WillRepeatedly(Return(nullptr));
MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
auto* media_channel = new MockVideoMediaChannel();
// The transport_name known by the video channel.
const std::string kVcName("vcname");
cricket::VideoChannel video_channel(
worker_thread_, network_thread_, nullptr, media_channel, kVcName,
kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
worker_thread_, network_thread_, nullptr, rtc::WrapUnique(media_channel),
kVcName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
AddOutgoingVideoTrackStats();
stats.AddStream(stream_);
@ -1290,12 +1291,12 @@ TEST_F(StatsCollectorTest, TransportObjectLinkedFromSsrcObject) {
TEST_F(StatsCollectorTest, RemoteSsrcInfoIsAbsent) {
StatsCollectorForTest stats(&pc_);
MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
auto* media_channel = new MockVideoMediaChannel();
// The transport_name known by the video channel.
const std::string kVcName("vcname");
cricket::VideoChannel video_channel(
worker_thread_, network_thread_, nullptr, media_channel, kVcName,
kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
worker_thread_, network_thread_, nullptr, rtc::WrapUnique(media_channel),
kVcName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
AddOutgoingVideoTrackStats();
stats.AddStream(stream_);
@ -1316,12 +1317,12 @@ TEST_F(StatsCollectorTest, RemoteSsrcInfoIsPresent) {
EXPECT_CALL(pc_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
.WillRepeatedly(Return(nullptr));
MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
auto* media_channel = new MockVideoMediaChannel();
// The transport_name known by the video channel.
const std::string kVcName("vcname");
cricket::VideoChannel video_channel(
worker_thread_, network_thread_, nullptr, media_channel, kVcName,
kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
worker_thread_, network_thread_, nullptr, rtc::WrapUnique(media_channel),
kVcName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
AddOutgoingVideoTrackStats();
stats.AddStream(stream_);
@ -1377,9 +1378,9 @@ TEST_F(StatsCollectorTest, ReportsFromRemoteTrack) {
new SessionStats(session_stats_));
}));
MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
auto* media_channel = new MockVideoMediaChannel();
cricket::VideoChannel video_channel(
worker_thread_, network_thread_, nullptr, media_channel,
worker_thread_, network_thread_, nullptr, rtc::WrapUnique(media_channel),
kVideoChannelName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
AddIncomingVideoTrackStats();
stats.AddStream(stream_);
@ -1685,12 +1686,13 @@ TEST_F(StatsCollectorTest, FilterOutNegativeInitialValues) {
EXPECT_CALL(pc_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
.WillRepeatedly(Return(nullptr));
MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
auto* media_channel = new MockVoiceMediaChannel();
// The transport_name known by the voice channel.
const std::string kVcName("vcname");
cricket::VoiceChannel voice_channel(
worker_thread_, network_thread_, nullptr, media_engine_, media_channel,
kVcName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
worker_thread_, network_thread_, nullptr, media_engine_,
rtc::WrapUnique(media_channel), kVcName, kDefaultRtcpMuxRequired,
kDefaultSrtpRequired);
// Create a local stream with a local audio track and adds it to the stats.
if (stream_ == NULL)
@ -1794,12 +1796,13 @@ TEST_F(StatsCollectorTest, GetStatsFromLocalAudioTrack) {
EXPECT_CALL(pc_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
.WillRepeatedly(Return(nullptr));
MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
auto* media_channel = new MockVoiceMediaChannel();
// The transport_name known by the voice channel.
const std::string kVcName("vcname");
cricket::VoiceChannel voice_channel(
worker_thread_, network_thread_, nullptr, media_engine_, media_channel,
kVcName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
worker_thread_, network_thread_, nullptr, media_engine_,
rtc::WrapUnique(media_channel), kVcName, kDefaultRtcpMuxRequired,
kDefaultSrtpRequired);
AddOutgoingAudioTrackStats();
stats.AddStream(stream_);
stats.AddLocalAudioTrack(audio_track_, kSsrcOfTrack);
@ -1829,12 +1832,13 @@ TEST_F(StatsCollectorTest, GetStatsFromRemoteStream) {
EXPECT_CALL(pc_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
.WillRepeatedly(Return(nullptr));
MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
auto* media_channel = new MockVoiceMediaChannel();
// The transport_name known by the voice channel.
const std::string kVcName("vcname");
cricket::VoiceChannel voice_channel(
worker_thread_, network_thread_, nullptr, media_engine_, media_channel,
kVcName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
worker_thread_, network_thread_, nullptr, media_engine_,
rtc::WrapUnique(media_channel), kVcName, kDefaultRtcpMuxRequired,
kDefaultSrtpRequired);
AddIncomingAudioTrackStats();
stats.AddStream(stream_);
@ -1858,12 +1862,13 @@ TEST_F(StatsCollectorTest, GetStatsAfterRemoveAudioStream) {
EXPECT_CALL(pc_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
.WillRepeatedly(Return(nullptr));
MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
auto* media_channel = new MockVoiceMediaChannel();
// The transport_name known by the voice channel.
const std::string kVcName("vcname");
cricket::VoiceChannel voice_channel(
worker_thread_, network_thread_, nullptr, media_engine_, media_channel,
kVcName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
worker_thread_, network_thread_, nullptr, media_engine_,
rtc::WrapUnique(media_channel), kVcName, kDefaultRtcpMuxRequired,
kDefaultSrtpRequired);
AddOutgoingAudioTrackStats();
stats.AddStream(stream_);
stats.AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
@ -1921,12 +1926,13 @@ TEST_F(StatsCollectorTest, LocalAndRemoteTracksWithSameSsrc) {
EXPECT_CALL(pc_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
.WillRepeatedly(Return(nullptr));
MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
auto* media_channel = new MockVoiceMediaChannel();
// The transport_name known by the voice channel.
const std::string kVcName("vcname");
cricket::VoiceChannel voice_channel(
worker_thread_, network_thread_, nullptr, media_engine_, media_channel,
kVcName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
worker_thread_, network_thread_, nullptr, media_engine_,
rtc::WrapUnique(media_channel), kVcName, kDefaultRtcpMuxRequired,
kDefaultSrtpRequired);
// Create a local stream with a local audio track and adds it to the stats.
AddOutgoingAudioTrackStats();
@ -2010,12 +2016,13 @@ TEST_F(StatsCollectorTest, TwoLocalTracksWithSameSsrc) {
EXPECT_CALL(pc_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
.WillRepeatedly(Return(nullptr));
MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
auto* media_channel = new MockVoiceMediaChannel();
// The transport_name known by the voice channel.
const std::string kVcName("vcname");
cricket::VoiceChannel voice_channel(
worker_thread_, network_thread_, nullptr, media_engine_, media_channel,
kVcName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
worker_thread_, network_thread_, nullptr, media_engine_,
rtc::WrapUnique(media_channel), kVcName, kDefaultRtcpMuxRequired,
kDefaultSrtpRequired);
// Create a local stream with a local audio track and adds it to the stats.
AddOutgoingAudioTrackStats();
@ -2072,9 +2079,9 @@ TEST_F(StatsCollectorTest, VerifyVideoSendSsrcStats) {
new SessionStats(session_stats_));
}));
MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
auto* media_channel = new MockVideoMediaChannel();
cricket::VideoChannel video_channel(
worker_thread_, network_thread_, nullptr, media_channel,
worker_thread_, network_thread_, nullptr, rtc::WrapUnique(media_channel),
kVideoChannelName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
StatsReports reports; // returned values.
cricket::VideoSenderInfo video_sender_info;
@ -2119,9 +2126,9 @@ TEST_F(StatsCollectorTest, VerifyVideoReceiveSsrcStats) {
new SessionStats(session_stats_));
}));
MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
auto* media_channel = new MockVideoMediaChannel();
cricket::VideoChannel video_channel(
worker_thread_, network_thread_, nullptr, media_channel,
worker_thread_, network_thread_, nullptr, rtc::WrapUnique(media_channel),
kVideoChannelName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
StatsReports reports; // returned values.
cricket::VideoReceiverInfo video_receiver_info;