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

Update pc/ to not use implicit conversion from scoped_refptr<T> to T*.

Browse Source 
Bug: webrtc:13464
Change-Id: I768646af8ded6338ef51486b8d69db1ad71e9a2c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/259500
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36588}
This commit is contained in:
Niels Möller 2022-04-20 14:26:50 +02:00 committed by WebRTC LUCI CQ
parent 46501b9192
commit afb246b5a9
43 changed files with 480 additions and 431 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
api/scoped_refptr.h
View File

@ -104,6 +104,7 @@ class scoped_refptr {
} }
T* get() const { return ptr_; } T* get() const { return ptr_; }
explicit operator bool() const { return ptr_ != nullptr; }
operator T*() const { return ptr_; } operator T*() const { return ptr_; }
T& operator*() const { return *ptr_; } T& operator*() const { return *ptr_; }
T* operator->() const { return ptr_; } T* operator->() const { return ptr_; }

4
pc/audio_rtp_receiver.cc
View File

@ -251,7 +251,7 @@ void AudioRtpReceiver::SetStreams(
} }
} }
if (removed) { if (removed) {
existing_stream->RemoveTrack(track_); existing_stream->RemoveTrack(track_.get());
} }
} }
// Add remote track to any streams that are new. // Add remote track to any streams that are new.
@ -265,7 +265,7 @@ void AudioRtpReceiver::SetStreams(
} }
} }
if (added) { if (added) {
stream->AddTrack(track_); stream->AddTrack(track_.get());
} }
} }
streams_ = streams; streams_ = streams;

2
pc/jsep_transport.cc
View File

@ -202,7 +202,7 @@ webrtc::RTCError JsepTransport::SetLocalJsepTransportDescription(
if (!local_fp) { if (!local_fp) {
local_certificate_ = nullptr; local_certificate_ = nullptr;
} else { } else {
error = VerifyCertificateFingerprint(local_certificate_, local_fp); error = VerifyCertificateFingerprint(local_certificate_.get(), local_fp);
if (!error.ok()) { if (!error.ok()) {
local_description_.reset(); local_description_.reset();
return error; return error;

8
pc/media_stream_observer.cc
View File

@ -54,7 +54,7 @@ void MediaStreamObserver::OnChanged() {
[cached_track](const AudioTrackVector::value_type& new_track) { [cached_track](const AudioTrackVector::value_type& new_track) {
return new_track->id() == cached_track->id(); return new_track->id() == cached_track->id();
})) { })) {
audio_track_removed_callback_(cached_track.get(), stream_); audio_track_removed_callback_(cached_track.get(), stream_.get());
} }
} }
@ -65,7 +65,7 @@ void MediaStreamObserver::OnChanged() {
[new_track](const AudioTrackVector::value_type& cached_track) { [new_track](const AudioTrackVector::value_type& cached_track) {
return new_track->id() == cached_track->id(); return new_track->id() == cached_track->id();
})) { })) {
audio_track_added_callback_(new_track.get(), stream_); audio_track_added_callback_(new_track.get(), stream_.get());
} }
} }
@ -76,7 +76,7 @@ void MediaStreamObserver::OnChanged() {
[cached_track](const VideoTrackVector::value_type& new_track) { [cached_track](const VideoTrackVector::value_type& new_track) {
return new_track->id() == cached_track->id(); return new_track->id() == cached_track->id();
})) { })) {
video_track_removed_callback_(cached_track.get(), stream_); video_track_removed_callback_(cached_track.get(), stream_.get());
} }
} }
@ -87,7 +87,7 @@ void MediaStreamObserver::OnChanged() {
[new_track](const VideoTrackVector::value_type& cached_track) { [new_track](const VideoTrackVector::value_type& cached_track) {
return new_track->id() == cached_track->id(); return new_track->id() == cached_track->id();
})) { })) {
video_track_added_callback_(new_track.get(), stream_); video_track_added_callback_(new_track.get(), stream_.get());
} }
} }

2
pc/media_stream_observer.h
View File

@ -34,7 +34,7 @@ class MediaStreamObserver : public ObserverInterface {
video_track_removed_callback); video_track_removed_callback);
~MediaStreamObserver() override; ~MediaStreamObserver() override;
const MediaStreamInterface* stream() const { return stream_; } const MediaStreamInterface* stream() const { return stream_.get(); }
void OnChanged() override; void OnChanged() override;

18
pc/media_stream_unittest.cc
View File

@ -66,10 +66,10 @@ class MediaStreamTest : public ::testing::Test {
ASSERT_TRUE(audio_track_.get() != NULL); ASSERT_TRUE(audio_track_.get() != NULL);
EXPECT_EQ(MediaStreamTrackInterface::kLive, audio_track_->state()); EXPECT_EQ(MediaStreamTrackInterface::kLive, audio_track_->state());
EXPECT_TRUE(stream_->AddTrack(video_track_)); EXPECT_TRUE(stream_->AddTrack(video_track_.get()));
EXPECT_FALSE(stream_->AddTrack(video_track_)); EXPECT_FALSE(stream_->AddTrack(video_track_.get()));
EXPECT_TRUE(stream_->AddTrack(audio_track_)); EXPECT_TRUE(stream_->AddTrack(audio_track_.get()));
EXPECT_FALSE(stream_->AddTrack(audio_track_)); EXPECT_FALSE(stream_->AddTrack(audio_track_.get()));
} }
void ChangeTrack(MediaStreamTrackInterface* track) { void ChangeTrack(MediaStreamTrackInterface* track) {
@ -118,17 +118,17 @@ TEST_F(MediaStreamTest, GetTrackInfo) {
} }
TEST_F(MediaStreamTest, RemoveTrack) { TEST_F(MediaStreamTest, RemoveTrack) {
MockObserver observer(stream_); MockObserver observer(stream_.get());
EXPECT_CALL(observer, OnChanged()).Times(Exactly(2)); EXPECT_CALL(observer, OnChanged()).Times(Exactly(2));
EXPECT_TRUE(stream_->RemoveTrack(audio_track_)); EXPECT_TRUE(stream_->RemoveTrack(audio_track_.get()));
EXPECT_FALSE(stream_->RemoveTrack(audio_track_)); EXPECT_FALSE(stream_->RemoveTrack(audio_track_.get()));
EXPECT_EQ(0u, stream_->GetAudioTracks().size()); EXPECT_EQ(0u, stream_->GetAudioTracks().size());
EXPECT_EQ(0u, stream_->GetAudioTracks().size()); EXPECT_EQ(0u, stream_->GetAudioTracks().size());
EXPECT_TRUE(stream_->RemoveTrack(video_track_)); EXPECT_TRUE(stream_->RemoveTrack(video_track_.get()));
EXPECT_FALSE(stream_->RemoveTrack(video_track_)); EXPECT_FALSE(stream_->RemoveTrack(video_track_.get()));
EXPECT_EQ(0u, stream_->GetVideoTracks().size()); EXPECT_EQ(0u, stream_->GetVideoTracks().size());
EXPECT_EQ(0u, stream_->GetVideoTracks().size()); EXPECT_EQ(0u, stream_->GetVideoTracks().size());

10
pc/peer_connection.cc
View File

@ -644,7 +644,7 @@ RTCError PeerConnection::Initialize(
stats_collector_ = RTCStatsCollector::Create(this); stats_collector_ = RTCStatsCollector::Create(this);
sdp_handler_ = SdpOfferAnswerHandler::Create(this, configuration, sdp_handler_ = SdpOfferAnswerHandler::Create(this, configuration,
dependencies, context_); dependencies, context_.get());
rtp_manager_ = std::make_unique<RtpTransmissionManager>( rtp_manager_ = std::make_unique<RtpTransmissionManager>(
IsUnifiedPlan(), signaling_thread(), worker_thread(), channel_manager(), IsUnifiedPlan(), signaling_thread(), worker_thread(), channel_manager(),
@ -858,7 +858,7 @@ RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::AddTrack(
LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_STATE, LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_STATE,
"PeerConnection is closed."); "PeerConnection is closed.");
} }
if (rtp_manager()->FindSenderForTrack(track)) { if (rtp_manager()->FindSenderForTrack(track.get())) {
LOG_AND_RETURN_ERROR( LOG_AND_RETURN_ERROR(
RTCErrorType::INVALID_PARAMETER, RTCErrorType::INVALID_PARAMETER,
"Sender already exists for track " + track->id() + "."); "Sender already exists for track " + track->id() + ".");
@ -866,7 +866,7 @@ RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::AddTrack(
auto sender_or_error = rtp_manager()->AddTrack(track, stream_ids); auto sender_or_error = rtp_manager()->AddTrack(track, stream_ids);
if (sender_or_error.ok()) { if (sender_or_error.ok()) {
sdp_handler_->UpdateNegotiationNeeded(); sdp_handler_->UpdateNegotiationNeeded();
stats_->AddTrack(track); stats_->AddTrack(track.get());
} }
return sender_or_error; return sender_or_error;
} }
@ -898,11 +898,11 @@ RTCError PeerConnection::RemoveTrackOrError(
bool removed; bool removed;
if (sender->media_type() == cricket::MEDIA_TYPE_AUDIO) { if (sender->media_type() == cricket::MEDIA_TYPE_AUDIO) {
removed = rtp_manager()->GetAudioTransceiver()->internal()->RemoveSender( removed = rtp_manager()->GetAudioTransceiver()->internal()->RemoveSender(
sender); sender.get());
} else { } else {
RTC_DCHECK_EQ(cricket::MEDIA_TYPE_VIDEO, sender->media_type()); RTC_DCHECK_EQ(cricket::MEDIA_TYPE_VIDEO, sender->media_type());
removed = rtp_manager()->GetVideoTransceiver()->internal()->RemoveSender( removed = rtp_manager()->GetVideoTransceiver()->internal()->RemoveSender(
sender); sender.get());
} }
if (!removed) { if (!removed) {
LOG_AND_RETURN_ERROR( LOG_AND_RETURN_ERROR(

2
pc/peer_connection_adaptation_integrationtest.cc
View File

@ -65,7 +65,7 @@ TrackWithPeriodicSource CreateTrackWithPeriodicSource(
periodic_track_source_config, /* remote */ false); periodic_track_source_config, /* remote */ false);
TrackWithPeriodicSource track_with_source; TrackWithPeriodicSource track_with_source;
track_with_source.track = track_with_source.track =
factory->CreateVideoTrack("PeriodicTrack", periodic_track_source); factory->CreateVideoTrack("PeriodicTrack", periodic_track_source.get());
track_with_source.periodic_track_source = periodic_track_source; track_with_source.periodic_track_source = periodic_track_source;
return track_with_source; return track_with_source;
} }

6
pc/peer_connection_crypto_unittest.cc
View File

@ -110,7 +110,7 @@ class PeerConnectionCryptoBaseTest : public ::testing::Test {
return nullptr; return nullptr;
} }
observer->SetPeerConnectionInterface(result.value()); observer->SetPeerConnectionInterface(result.value().get());
return std::make_unique<PeerConnectionWrapper>( return std::make_unique<PeerConnectionWrapper>(
pc_factory_, result.MoveValue(), std::move(observer)); pc_factory_, result.MoveValue(), std::move(observer));
} }
@ -662,10 +662,10 @@ TEST_P(PeerConnectionCryptoDtlsCertGenTest, TestCertificateGeneration) {
rtc::make_ref_counted<MockCreateSessionDescriptionObserver>(); rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
observers.push_back(observer); observers.push_back(observer);
if (sdp_type_ == SdpType::kOffer) { if (sdp_type_ == SdpType::kOffer) {
pc->pc()->CreateOffer(observer, pc->pc()->CreateOffer(observer.get(),
PeerConnectionInterface::RTCOfferAnswerOptions()); PeerConnectionInterface::RTCOfferAnswerOptions());
} else { } else {
pc->pc()->CreateAnswer(observer, pc->pc()->CreateAnswer(observer.get(),
PeerConnectionInterface::RTCOfferAnswerOptions()); PeerConnectionInterface::RTCOfferAnswerOptions());
} }
} }

2
pc/peer_connection_data_channel_unittest.cc
View File

@ -144,7 +144,7 @@ class PeerConnectionDataChannelBaseTest : public ::testing::Test {
return nullptr; return nullptr;
} }
observer->SetPeerConnectionInterface(result.value()); observer->SetPeerConnectionInterface(result.value().get());
auto wrapper = std::make_unique<PeerConnectionWrapperForDataChannelTest>( auto wrapper = std::make_unique<PeerConnectionWrapperForDataChannelTest>(
pc_factory, result.MoveValue(), std::move(observer)); pc_factory, result.MoveValue(), std::move(observer));
wrapper->set_sctp_transport_factory(fake_sctp_transport_factory); wrapper->set_sctp_transport_factory(fake_sctp_transport_factory);

80
pc/peer_connection_end_to_end_unittest.cc
View File

@ -509,14 +509,16 @@ TEST_P(PeerConnectionEndToEndTest, CreateDataChannelBeforeNegotiate) {
Negotiate(); Negotiate();
WaitForConnection(); WaitForConnection();
WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 0); WaitForDataChannelsToOpen(caller_dc.get(), callee_signaled_data_channels_, 0);
WaitForDataChannelsToOpen(callee_dc, caller_signaled_data_channels_, 0); WaitForDataChannelsToOpen(callee_dc.get(), caller_signaled_data_channels_, 0);
TestDataChannelSendAndReceive(caller_dc, callee_signaled_data_channels_[0]); TestDataChannelSendAndReceive(caller_dc.get(),
TestDataChannelSendAndReceive(callee_dc, caller_signaled_data_channels_[0]); callee_signaled_data_channels_[0].get());
TestDataChannelSendAndReceive(callee_dc.get(),
caller_signaled_data_channels_[0].get());
CloseDataChannels(caller_dc, callee_signaled_data_channels_, 0); CloseDataChannels(caller_dc.get(), callee_signaled_data_channels_, 0);
CloseDataChannels(callee_dc, caller_signaled_data_channels_, 0); CloseDataChannels(callee_dc.get(), caller_signaled_data_channels_, 0);
} }
// Verifies that a DataChannel created after the negotiation can transition to // Verifies that a DataChannel created after the negotiation can transition to
@ -534,7 +536,7 @@ TEST_P(PeerConnectionEndToEndTest, CreateDataChannelAfterNegotiate) {
WaitForConnection(); WaitForConnection();
// Wait for the data channel created pre-negotiation to be opened. // Wait for the data channel created pre-negotiation to be opened.
WaitForDataChannelsToOpen(dummy, callee_signaled_data_channels_, 0); WaitForDataChannelsToOpen(dummy.get(), callee_signaled_data_channels_, 0);
// Create new DataChannels after the negotiation and verify their states. // Create new DataChannels after the negotiation and verify their states.
rtc::scoped_refptr<DataChannelInterface> caller_dc( rtc::scoped_refptr<DataChannelInterface> caller_dc(
@ -542,14 +544,16 @@ TEST_P(PeerConnectionEndToEndTest, CreateDataChannelAfterNegotiate) {
rtc::scoped_refptr<DataChannelInterface> callee_dc( rtc::scoped_refptr<DataChannelInterface> callee_dc(
callee_->CreateDataChannel("hello", init)); callee_->CreateDataChannel("hello", init));
WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 1); WaitForDataChannelsToOpen(caller_dc.get(), callee_signaled_data_channels_, 1);
WaitForDataChannelsToOpen(callee_dc, caller_signaled_data_channels_, 0); WaitForDataChannelsToOpen(callee_dc.get(), caller_signaled_data_channels_, 0);
TestDataChannelSendAndReceive(caller_dc, callee_signaled_data_channels_[1]); TestDataChannelSendAndReceive(caller_dc.get(),
TestDataChannelSendAndReceive(callee_dc, caller_signaled_data_channels_[0]); callee_signaled_data_channels_[1].get());
TestDataChannelSendAndReceive(callee_dc.get(),
caller_signaled_data_channels_[0].get());
CloseDataChannels(caller_dc, callee_signaled_data_channels_, 1); CloseDataChannels(caller_dc.get(), callee_signaled_data_channels_, 1);
CloseDataChannels(callee_dc, caller_signaled_data_channels_, 0); CloseDataChannels(callee_dc.get(), caller_signaled_data_channels_, 0);
} }
// Verifies that a DataChannel created can transfer large messages. // Verifies that a DataChannel created can transfer large messages.
@ -566,7 +570,7 @@ TEST_P(PeerConnectionEndToEndTest, CreateDataChannelLargeTransfer) {
WaitForConnection(); WaitForConnection();
// Wait for the data channel created pre-negotiation to be opened. // Wait for the data channel created pre-negotiation to be opened.
WaitForDataChannelsToOpen(dummy, callee_signaled_data_channels_, 0); WaitForDataChannelsToOpen(dummy.get(), callee_signaled_data_channels_, 0);
// Create new DataChannels after the negotiation and verify their states. // Create new DataChannels after the negotiation and verify their states.
rtc::scoped_refptr<DataChannelInterface> caller_dc( rtc::scoped_refptr<DataChannelInterface> caller_dc(
@ -574,16 +578,16 @@ TEST_P(PeerConnectionEndToEndTest, CreateDataChannelLargeTransfer) {
rtc::scoped_refptr<DataChannelInterface> callee_dc( rtc::scoped_refptr<DataChannelInterface> callee_dc(
callee_->CreateDataChannel("hello", init)); callee_->CreateDataChannel("hello", init));
WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 1); WaitForDataChannelsToOpen(caller_dc.get(), callee_signaled_data_channels_, 1);
WaitForDataChannelsToOpen(callee_dc, caller_signaled_data_channels_, 0); WaitForDataChannelsToOpen(callee_dc.get(), caller_signaled_data_channels_, 0);
TestDataChannelSendAndReceive(caller_dc, callee_signaled_data_channels_[1], TestDataChannelSendAndReceive(
256 * 1024); caller_dc.get(), callee_signaled_data_channels_[1].get(), 256 * 1024);
TestDataChannelSendAndReceive(callee_dc, caller_signaled_data_channels_[0], TestDataChannelSendAndReceive(
256 * 1024); callee_dc.get(), caller_signaled_data_channels_[0].get(), 256 * 1024);
CloseDataChannels(caller_dc, callee_signaled_data_channels_, 1); CloseDataChannels(caller_dc.get(), callee_signaled_data_channels_, 1);
CloseDataChannels(callee_dc, caller_signaled_data_channels_, 0); CloseDataChannels(callee_dc.get(), caller_signaled_data_channels_, 0);
} }
// Verifies that DataChannel IDs are even/odd based on the DTLS roles. // Verifies that DataChannel IDs are even/odd based on the DTLS roles.
@ -628,14 +632,18 @@ TEST_P(PeerConnectionEndToEndTest,
Negotiate(); Negotiate();
WaitForConnection(); WaitForConnection();
WaitForDataChannelsToOpen(caller_dc_1, callee_signaled_data_channels_, 0); WaitForDataChannelsToOpen(caller_dc_1.get(), callee_signaled_data_channels_,
WaitForDataChannelsToOpen(caller_dc_2, callee_signaled_data_channels_, 1); 0);
WaitForDataChannelsToOpen(caller_dc_2.get(), callee_signaled_data_channels_,
1);
std::unique_ptr<webrtc::MockDataChannelObserver> dc_1_observer( std::unique_ptr<webrtc::MockDataChannelObserver> dc_1_observer(
new webrtc::MockDataChannelObserver(callee_signaled_data_channels_[0])); new webrtc::MockDataChannelObserver(
callee_signaled_data_channels_[0].get()));
std::unique_ptr<webrtc::MockDataChannelObserver> dc_2_observer( std::unique_ptr<webrtc::MockDataChannelObserver> dc_2_observer(
new webrtc::MockDataChannelObserver(callee_signaled_data_channels_[1])); new webrtc::MockDataChannelObserver(
callee_signaled_data_channels_[1].get()));
const std::string message_1 = "hello 1"; const std::string message_1 = "hello 1";
const std::string message_2 = "hello 2"; const std::string message_2 = "hello 2";
@ -666,7 +674,7 @@ TEST_P(PeerConnectionEndToEndTest,
Negotiate(); Negotiate();
WaitForConnection(); WaitForConnection();
WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 0); WaitForDataChannelsToOpen(caller_dc.get(), callee_signaled_data_channels_, 0);
int first_channel_id = caller_dc->id(); int first_channel_id = caller_dc->id();
// Wait for the local side to say it's closed, but not the remote side. // Wait for the local side to say it's closed, but not the remote side.
// Previously, the channel on which Close is called reported being closed // Previously, the channel on which Close is called reported being closed
@ -676,13 +684,14 @@ TEST_P(PeerConnectionEndToEndTest,
// Create a new channel and ensure it works after closing the previous one. // Create a new channel and ensure it works after closing the previous one.
caller_dc = caller_->CreateDataChannel("data2", init); caller_dc = caller_->CreateDataChannel("data2", init);
WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 1); WaitForDataChannelsToOpen(caller_dc.get(), callee_signaled_data_channels_, 1);
// Since the second channel was created after the first finished closing, it // Since the second channel was created after the first finished closing, it
// should be able to re-use the first one's ID. // should be able to re-use the first one's ID.
EXPECT_EQ(first_channel_id, caller_dc->id()); EXPECT_EQ(first_channel_id, caller_dc->id());
TestDataChannelSendAndReceive(caller_dc, callee_signaled_data_channels_[1]); TestDataChannelSendAndReceive(caller_dc.get(),
callee_signaled_data_channels_[1].get());
CloseDataChannels(caller_dc, callee_signaled_data_channels_, 1); CloseDataChannels(caller_dc.get(), callee_signaled_data_channels_, 1);
} }
// Similar to the above test, but don't wait for the first channel to finish // Similar to the above test, but don't wait for the first channel to finish
@ -699,20 +708,21 @@ TEST_P(PeerConnectionEndToEndTest,
Negotiate(); Negotiate();
WaitForConnection(); WaitForConnection();
WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 0); WaitForDataChannelsToOpen(caller_dc.get(), callee_signaled_data_channels_, 0);
int first_channel_id = caller_dc->id(); int first_channel_id = caller_dc->id();
caller_dc->Close(); caller_dc->Close();
// Immediately create a new channel, before waiting for the previous one to // Immediately create a new channel, before waiting for the previous one to
// transition to "closed". // transition to "closed".
caller_dc = caller_->CreateDataChannel("data2", init); caller_dc = caller_->CreateDataChannel("data2", init);
WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 1); WaitForDataChannelsToOpen(caller_dc.get(), callee_signaled_data_channels_, 1);
// Since the second channel was created while the first was still closing, // Since the second channel was created while the first was still closing,
// it should have been assigned a different ID. // it should have been assigned a different ID.
EXPECT_NE(first_channel_id, caller_dc->id()); EXPECT_NE(first_channel_id, caller_dc->id());
TestDataChannelSendAndReceive(caller_dc, callee_signaled_data_channels_[1]); TestDataChannelSendAndReceive(caller_dc.get(),
callee_signaled_data_channels_[1].get());
CloseDataChannels(caller_dc, callee_signaled_data_channels_, 1); CloseDataChannels(caller_dc.get(), callee_signaled_data_channels_, 1);
} }
// This tests that if a data channel is closed remotely while not referenced // This tests that if a data channel is closed remotely while not referenced
@ -730,7 +740,7 @@ TEST_P(PeerConnectionEndToEndTest, CloseDataChannelRemotelyWhileNotReferenced) {
Negotiate(); Negotiate();
WaitForConnection(); WaitForConnection();
WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 0); WaitForDataChannelsToOpen(caller_dc.get(), callee_signaled_data_channels_, 0);
// This removes the reference to the remote data channel that we hold. // This removes the reference to the remote data channel that we hold.
callee_signaled_data_channels_.clear(); callee_signaled_data_channels_.clear();
caller_dc->Close(); caller_dc->Close();

4
pc/peer_connection_factory_unittest.cc
View File

@ -472,9 +472,9 @@ TEST_F(PeerConnectionFactoryTest, LocalRendering) {
ASSERT_TRUE(source.get() != NULL); ASSERT_TRUE(source.get() != NULL);
rtc::scoped_refptr<VideoTrackInterface> track( rtc::scoped_refptr<VideoTrackInterface> track(
factory_->CreateVideoTrack("testlabel", source)); factory_->CreateVideoTrack("testlabel", source.get()));
ASSERT_TRUE(track.get() != NULL); ASSERT_TRUE(track.get() != NULL);
FakeVideoTrackRenderer local_renderer(track); FakeVideoTrackRenderer local_renderer(track.get());
EXPECT_EQ(0, local_renderer.num_rendered_frames()); EXPECT_EQ(0, local_renderer.num_rendered_frames());
source->InjectFrame(frame_source.GetFrame()); source->InjectFrame(frame_source.GetFrame());

2
pc/peer_connection_header_extension_unittest.cc
View File

@ -106,7 +106,7 @@ class PeerConnectionHeaderExtensionTest
auto result = pc_factory->CreatePeerConnectionOrError( auto result = pc_factory->CreatePeerConnectionOrError(
config, std::move(pc_dependencies)); config, std::move(pc_dependencies));
EXPECT_TRUE(result.ok()); EXPECT_TRUE(result.ok());
observer->SetPeerConnectionInterface(result.value()); observer->SetPeerConnectionInterface(result.value().get());
return std::make_unique<PeerConnectionWrapper>( return std::make_unique<PeerConnectionWrapper>(
pc_factory, result.MoveValue(), std::move(observer)); pc_factory, result.MoveValue(), std::move(observer));
} }

2
pc/peer_connection_histogram_unittest.cc
View File

@ -352,7 +352,7 @@ class PeerConnectionUsageHistogramTest : public ::testing::Test {
return nullptr; return nullptr;
} }
observer->SetPeerConnectionInterface(result.value()); observer->SetPeerConnectionInterface(result.value().get());
auto wrapper = std::make_unique<PeerConnectionWrapperForUsageHistogramTest>( auto wrapper = std::make_unique<PeerConnectionWrapperForUsageHistogramTest>(
pc_factory, result.MoveValue(), std::move(observer)); pc_factory, result.MoveValue(), std::move(observer));
return wrapper; return wrapper;

6
pc/peer_connection_ice_unittest.cc
View File

@ -175,7 +175,7 @@ class PeerConnectionIceBaseTest : public ::testing::Test {
return nullptr; return nullptr;
} }
observer->SetPeerConnectionInterface(result.value()); observer->SetPeerConnectionInterface(result.value().get());
auto wrapper = std::make_unique<PeerConnectionWrapperForIceTest>( auto wrapper = std::make_unique<PeerConnectionWrapperForIceTest>(
pc_factory_, result.MoveValue(), std::move(observer)); pc_factory_, result.MoveValue(), std::move(observer));
wrapper->set_network(fake_network); wrapper->set_network(fake_network);
@ -809,7 +809,7 @@ TEST_P(PeerConnectionIceTest,
// Chain an operation that will block AddIceCandidate() from executing. // Chain an operation that will block AddIceCandidate() from executing.
auto answer_observer = auto answer_observer =
rtc::make_ref_counted<MockCreateSessionDescriptionObserver>(); rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
callee->pc()->CreateAnswer(answer_observer, RTCOfferAnswerOptions()); callee->pc()->CreateAnswer(answer_observer.get(), RTCOfferAnswerOptions());
auto jsep_candidate = auto jsep_candidate =
callee->CreateJsepCandidateForFirstTransport(&candidate); callee->CreateJsepCandidateForFirstTransport(&candidate);
@ -857,7 +857,7 @@ TEST_P(PeerConnectionIceTest,
// Chain an operation that will block AddIceCandidate() from executing. // Chain an operation that will block AddIceCandidate() from executing.
auto answer_observer = auto answer_observer =
rtc::make_ref_counted<MockCreateSessionDescriptionObserver>(); rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
callee->pc()->CreateAnswer(answer_observer, RTCOfferAnswerOptions()); callee->pc()->CreateAnswer(answer_observer.get(), RTCOfferAnswerOptions());
auto jsep_candidate = auto jsep_candidate =
callee->CreateJsepCandidateForFirstTransport(&candidate); callee->CreateJsepCandidateForFirstTransport(&candidate);

47
pc/peer_connection_integrationtest.cc
View File

@ -578,7 +578,8 @@ TEST_P(PeerConnectionIntegrationTest, AudioToVideoUpgrade) {
ASSERT_EQ(2U, transceivers.size()); ASSERT_EQ(2U, transceivers.size());
ASSERT_EQ(cricket::MEDIA_TYPE_VIDEO, ASSERT_EQ(cricket::MEDIA_TYPE_VIDEO,
transceivers[1]->receiver()->media_type()); transceivers[1]->receiver()->media_type());
transceivers[1]->sender()->SetTrack(caller()->CreateLocalVideoTrack()); transceivers[1]->sender()->SetTrack(
caller()->CreateLocalVideoTrack().get());
transceivers[1]->SetDirectionWithError( transceivers[1]->SetDirectionWithError(
RtpTransceiverDirection::kSendRecv); RtpTransceiverDirection::kSendRecv);
}); });
@ -1333,7 +1334,8 @@ TEST_P(PeerConnectionIntegrationTest, GetBytesReceivedStatsWithOldStatsApi) {
for (const auto& receiver : callee()->pc()->GetReceivers()) { for (const auto& receiver : callee()->pc()->GetReceivers()) {
// We received frames, so we definitely should have nonzero "received bytes" // We received frames, so we definitely should have nonzero "received bytes"
// stats at this point. // stats at this point.
EXPECT_GT(callee()->OldGetStatsForTrack(receiver->track())->BytesReceived(), EXPECT_GT(
callee()->OldGetStatsForTrack(receiver->track().get())->BytesReceived(),
0); 0);
} }
} }
@ -1355,8 +1357,8 @@ TEST_P(PeerConnectionIntegrationTest, GetBytesSentStatsWithOldStatsApi) {
// The callee received frames, so we definitely should have nonzero "sent // The callee received frames, so we definitely should have nonzero "sent
// bytes" stats at this point. // bytes" stats at this point.
EXPECT_GT(caller()->OldGetStatsForTrack(audio_track)->BytesSent(), 0); EXPECT_GT(caller()->OldGetStatsForTrack(audio_track.get())->BytesSent(), 0);
EXPECT_GT(caller()->OldGetStatsForTrack(video_track)->BytesSent(), 0); EXPECT_GT(caller()->OldGetStatsForTrack(video_track.get())->BytesSent(), 0);
} }
// Test that we can get capture start ntp time. // Test that we can get capture start ntp time.
@ -1379,9 +1381,8 @@ TEST_P(PeerConnectionIntegrationTest, GetCaptureStartNtpTimeWithOldStatsApi) {
// Get the audio output level stats. Note that the level is not available // Get the audio output level stats. Note that the level is not available
// until an RTCP packet has been received. // until an RTCP packet has been received.
EXPECT_TRUE_WAIT( EXPECT_TRUE_WAIT(callee()->OldGetStatsForTrack(remote_audio_track.get())
callee()->OldGetStatsForTrack(remote_audio_track)->CaptureStartNtpTime() > ->CaptureStartNtpTime() > 0,
0,
2 * kMaxWaitForFramesMs); 2 * kMaxWaitForFramesMs);
} }
@ -2434,10 +2435,14 @@ TEST_F(PeerConnectionIntegrationTestPlanB,
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected, EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kMaxWaitForFramesMs); callee()->ice_connection_state(), kMaxWaitForFramesMs);
// Now set the tracks, and expect frames to immediately start flowing. // Now set the tracks, and expect frames to immediately start flowing.
EXPECT_TRUE(caller_audio_sender->SetTrack(caller()->CreateLocalAudioTrack())); EXPECT_TRUE(
EXPECT_TRUE(caller_video_sender->SetTrack(caller()->CreateLocalVideoTrack())); caller_audio_sender->SetTrack(caller()->CreateLocalAudioTrack().get()));
EXPECT_TRUE(callee_audio_sender->SetTrack(callee()->CreateLocalAudioTrack())); EXPECT_TRUE(
EXPECT_TRUE(callee_video_sender->SetTrack(callee()->CreateLocalVideoTrack())); caller_video_sender->SetTrack(caller()->CreateLocalVideoTrack().get()));
EXPECT_TRUE(
callee_audio_sender->SetTrack(callee()->CreateLocalAudioTrack().get()));
EXPECT_TRUE(
callee_video_sender->SetTrack(callee()->CreateLocalVideoTrack().get()));
MediaExpectations media_expectations; MediaExpectations media_expectations;
media_expectations.ExpectBidirectionalAudioAndVideo(); media_expectations.ExpectBidirectionalAudioAndVideo();
ASSERT_TRUE(ExpectNewFrames(media_expectations)); ASSERT_TRUE(ExpectNewFrames(media_expectations));
@ -2473,10 +2478,14 @@ TEST_F(PeerConnectionIntegrationTestUnifiedPlan,
// Now set the tracks, and expect frames to immediately start flowing. // Now set the tracks, and expect frames to immediately start flowing.
auto callee_audio_sender = callee()->pc()->GetSenders()[0]; auto callee_audio_sender = callee()->pc()->GetSenders()[0];
auto callee_video_sender = callee()->pc()->GetSenders()[1]; auto callee_video_sender = callee()->pc()->GetSenders()[1];
ASSERT_TRUE(caller_audio_sender->SetTrack(caller()->CreateLocalAudioTrack())); ASSERT_TRUE(
ASSERT_TRUE(caller_video_sender->SetTrack(caller()->CreateLocalVideoTrack())); caller_audio_sender->SetTrack(caller()->CreateLocalAudioTrack().get()));
ASSERT_TRUE(callee_audio_sender->SetTrack(callee()->CreateLocalAudioTrack())); ASSERT_TRUE(
ASSERT_TRUE(callee_video_sender->SetTrack(callee()->CreateLocalVideoTrack())); caller_video_sender->SetTrack(caller()->CreateLocalVideoTrack().get()));
ASSERT_TRUE(
callee_audio_sender->SetTrack(callee()->CreateLocalAudioTrack().get()));
ASSERT_TRUE(
callee_video_sender->SetTrack(callee()->CreateLocalVideoTrack().get()));
MediaExpectations media_expectations; MediaExpectations media_expectations;
media_expectations.ExpectBidirectionalAudioAndVideo(); media_expectations.ExpectBidirectionalAudioAndVideo();
ASSERT_TRUE(ExpectNewFrames(media_expectations)); ASSERT_TRUE(ExpectNewFrames(media_expectations));
@ -2841,7 +2850,7 @@ TEST_P(PeerConnectionIntegrationTest, IceTransportFactoryUsedForConnections) {
ASSERT_TRUE(wrapper); ASSERT_TRUE(wrapper);
wrapper->CreateDataChannel(); wrapper->CreateDataChannel();
auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>(); auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
wrapper->pc()->SetLocalDescription(observer, wrapper->pc()->SetLocalDescription(observer.get(),
wrapper->CreateOfferAndWait().release()); wrapper->CreateOfferAndWait().release());
} }
@ -3326,7 +3335,7 @@ TEST_F(PeerConnectionIntegrationTestUnifiedPlan,
caller()->AddVideoTrack(); caller()->AddVideoTrack();
callee()->AddVideoTrack(); callee()->AddVideoTrack();
auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>(); auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
callee()->pc()->SetLocalDescription(observer, callee()->pc()->SetLocalDescription(observer.get(),
callee()->CreateOfferAndWait().release()); callee()->CreateOfferAndWait().release());
EXPECT_TRUE_WAIT(observer->called(), kDefaultTimeout); EXPECT_TRUE_WAIT(observer->called(), kDefaultTimeout);
caller()->CreateAndSetAndSignalOffer(); // Implicit rollback. caller()->CreateAndSetAndSignalOffer(); // Implicit rollback.
@ -3344,7 +3353,7 @@ TEST_F(PeerConnectionIntegrationTestUnifiedPlan,
auto sld_observer = auto sld_observer =
rtc::make_ref_counted<MockSetSessionDescriptionObserver>(); rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
callee()->pc()->SetLocalDescription(sld_observer, callee()->pc()->SetLocalDescription(sld_observer.get(),
callee()->CreateOfferAndWait().release()); callee()->CreateOfferAndWait().release());
EXPECT_TRUE_WAIT(sld_observer->called(), kDefaultTimeout); EXPECT_TRUE_WAIT(sld_observer->called(), kDefaultTimeout);
EXPECT_EQ(sld_observer->error(), ""); EXPECT_EQ(sld_observer->error(), "");
@ -3352,7 +3361,7 @@ TEST_F(PeerConnectionIntegrationTestUnifiedPlan,
auto srd_observer = auto srd_observer =
rtc::make_ref_counted<MockSetSessionDescriptionObserver>(); rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
callee()->pc()->SetRemoteDescription( callee()->pc()->SetRemoteDescription(
srd_observer, caller()->CreateOfferAndWait().release()); srd_observer.get(), caller()->CreateOfferAndWait().release());
EXPECT_TRUE_WAIT(srd_observer->called(), kDefaultTimeout); EXPECT_TRUE_WAIT(srd_observer->called(), kDefaultTimeout);
EXPECT_EQ(srd_observer->error(), ""); EXPECT_EQ(srd_observer->error(), "");

139
pc/peer_connection_interface_unittest.cc
View File

@ -549,14 +549,14 @@ rtc::scoped_refptr<StreamCollection> CreateStreamCollection(
rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track( rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
webrtc::AudioTrack::Create(kAudioTracks[i * tracks_per_stream + j], webrtc::AudioTrack::Create(kAudioTracks[i * tracks_per_stream + j],
nullptr)); nullptr));
stream->AddTrack(audio_track); stream->AddTrack(audio_track.get());
// Add a local video track. // Add a local video track.
rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track( rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
webrtc::VideoTrack::Create(kVideoTracks[i * tracks_per_stream + j], webrtc::VideoTrack::Create(kVideoTracks[i * tracks_per_stream + j],
webrtc::FakeVideoTrackSource::Create(), webrtc::FakeVideoTrackSource::Create(),
rtc::Thread::Current())); rtc::Thread::Current()));
stream->AddTrack(video_track); stream->AddTrack(video_track.get());
} }
local_collection->AddStream(stream); local_collection->AddStream(stream);
@ -810,13 +810,14 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
} }
void ReleasePeerConnection() { void ReleasePeerConnection() {
pc_ = NULL; pc_ = nullptr;
observer_.SetPeerConnectionInterface(NULL); observer_.SetPeerConnectionInterface(nullptr);
} }
rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack( rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack(
const std::string& label) { const std::string& label) {
return pc_factory_->CreateVideoTrack(label, FakeVideoTrackSource::Create()); return pc_factory_->CreateVideoTrack(label,
FakeVideoTrackSource::Create().get());
} }
void AddVideoTrack(const std::string& track_label, void AddVideoTrack(const std::string& track_label,
@ -829,8 +830,8 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
void AddVideoStream(const std::string& label) { void AddVideoStream(const std::string& label) {
rtc::scoped_refptr<MediaStreamInterface> stream( rtc::scoped_refptr<MediaStreamInterface> stream(
pc_factory_->CreateLocalMediaStream(label)); pc_factory_->CreateLocalMediaStream(label));
stream->AddTrack(CreateVideoTrack(label + "v0")); stream->AddTrack(CreateVideoTrack(label + "v0").get());
ASSERT_TRUE(pc_->AddStream(stream)); ASSERT_TRUE(pc_->AddStream(stream.get()));
} }
rtc::scoped_refptr<AudioTrackInterface> CreateAudioTrack( rtc::scoped_refptr<AudioTrackInterface> CreateAudioTrack(
@ -848,8 +849,8 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
void AddAudioStream(const std::string& label) { void AddAudioStream(const std::string& label) {
rtc::scoped_refptr<MediaStreamInterface> stream( rtc::scoped_refptr<MediaStreamInterface> stream(
pc_factory_->CreateLocalMediaStream(label)); pc_factory_->CreateLocalMediaStream(label));
stream->AddTrack(CreateAudioTrack(label + "a0")); stream->AddTrack(CreateAudioTrack(label + "a0").get());
ASSERT_TRUE(pc_->AddStream(stream)); ASSERT_TRUE(pc_->AddStream(stream.get()));
} }
void AddAudioVideoStream(const std::string& stream_id, void AddAudioVideoStream(const std::string& stream_id,
@ -858,9 +859,9 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
// Create a local stream. // Create a local stream.
rtc::scoped_refptr<MediaStreamInterface> stream( rtc::scoped_refptr<MediaStreamInterface> stream(
pc_factory_->CreateLocalMediaStream(stream_id)); pc_factory_->CreateLocalMediaStream(stream_id));
stream->AddTrack(CreateAudioTrack(audio_track_label)); stream->AddTrack(CreateAudioTrack(audio_track_label).get());
stream->AddTrack(CreateVideoTrack(video_track_label)); stream->AddTrack(CreateVideoTrack(video_track_label).get());
ASSERT_TRUE(pc_->AddStream(stream)); ASSERT_TRUE(pc_->AddStream(stream.get()));
} }
rtc::scoped_refptr<RtpReceiverInterface> GetFirstReceiverOfType( rtc::scoped_refptr<RtpReceiverInterface> GetFirstReceiverOfType(
@ -879,9 +880,11 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
auto observer = auto observer =
rtc::make_ref_counted<MockCreateSessionDescriptionObserver>(); rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
if (offer) { if (offer) {
pc_->CreateOffer(observer, options ? *options : RTCOfferAnswerOptions()); pc_->CreateOffer(observer.get(),
options ? *options : RTCOfferAnswerOptions());
} else { } else {
pc_->CreateAnswer(observer, options ? *options : RTCOfferAnswerOptions()); pc_->CreateAnswer(observer.get(),
options ? *options : RTCOfferAnswerOptions());
} }
EXPECT_EQ_WAIT(true, observer->called(), kTimeout); EXPECT_EQ_WAIT(true, observer->called(), kTimeout);
*desc = observer->MoveDescription(); *desc = observer->MoveDescription();
@ -903,9 +906,9 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
bool local) { bool local) {
auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>(); auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
if (local) { if (local) {
pc_->SetLocalDescription(observer, desc.release()); pc_->SetLocalDescription(observer.get(), desc.release());
} else { } else {
pc_->SetRemoteDescription(observer, desc.release()); pc_->SetRemoteDescription(observer.get(), desc.release());
} }
if (pc_->signaling_state() != PeerConnectionInterface::kClosed) { if (pc_->signaling_state() != PeerConnectionInterface::kClosed) {
EXPECT_EQ_WAIT(true, observer->called(), kTimeout); EXPECT_EQ_WAIT(true, observer->called(), kTimeout);
@ -928,7 +931,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
// be required. // be required.
bool DoGetStats(MediaStreamTrackInterface* track) { bool DoGetStats(MediaStreamTrackInterface* track) {
auto observer = rtc::make_ref_counted<MockStatsObserver>(); auto observer = rtc::make_ref_counted<MockStatsObserver>();
if (!pc_->GetStats(observer, track, if (!pc_->GetStats(observer.get(), track,
PeerConnectionInterface::kStatsOutputLevelStandard)) PeerConnectionInterface::kStatsOutputLevelStandard))
return false; return false;
EXPECT_TRUE_WAIT(observer->called(), kTimeout); EXPECT_TRUE_WAIT(observer->called(), kTimeout);
@ -939,7 +942,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
bool DoGetRTCStats() { bool DoGetRTCStats() {
auto callback = auto callback =
rtc::make_ref_counted<webrtc::MockRTCStatsCollectorCallback>(); rtc::make_ref_counted<webrtc::MockRTCStatsCollectorCallback>();
pc_->GetStats(callback); pc_->GetStats(callback.get());
EXPECT_TRUE_WAIT(callback->called(), kTimeout); EXPECT_TRUE_WAIT(callback->called(), kTimeout);
return callback->called(); return callback->called();
} }
@ -963,12 +966,12 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
const cricket::MediaContentDescription* desc = const cricket::MediaContentDescription* desc =
cricket::GetFirstAudioContentDescription( cricket::GetFirstAudioContentDescription(
pc_->remote_description()->description()); pc_->remote_description()->description());
ASSERT_TRUE(desc != NULL); ASSERT_TRUE(desc != nullptr);
EXPECT_GT(desc->rtp_header_extensions().size(), 0u); EXPECT_GT(desc->rtp_header_extensions().size(), 0u);
desc = cricket::GetFirstVideoContentDescription( desc = cricket::GetFirstVideoContentDescription(
pc_->remote_description()->description()); pc_->remote_description()->description());
ASSERT_TRUE(desc != NULL); ASSERT_TRUE(desc != nullptr);
EXPECT_GT(desc->rtp_header_extensions().size(), 0u); EXPECT_GT(desc->rtp_header_extensions().size(), 0u);
} }
@ -1115,21 +1118,21 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
if (number_of_audio_tracks > 0) { if (number_of_audio_tracks > 0) {
sdp_ms1 += std::string(kSdpStringAudio); sdp_ms1 += std::string(kSdpStringAudio);
sdp_ms1 += std::string(kSdpStringMs1Audio0); sdp_ms1 += std::string(kSdpStringMs1Audio0);
AddAudioTrack(kAudioTracks[0], stream); AddAudioTrack(kAudioTracks[0], stream.get());
} }
if (number_of_audio_tracks > 1) { if (number_of_audio_tracks > 1) {
sdp_ms1 += kSdpStringMs1Audio1; sdp_ms1 += kSdpStringMs1Audio1;
AddAudioTrack(kAudioTracks[1], stream); AddAudioTrack(kAudioTracks[1], stream.get());
} }
if (number_of_video_tracks > 0) { if (number_of_video_tracks > 0) {
sdp_ms1 += std::string(kSdpStringVideo); sdp_ms1 += std::string(kSdpStringVideo);
sdp_ms1 += std::string(kSdpStringMs1Video0); sdp_ms1 += std::string(kSdpStringMs1Video0);
AddVideoTrack(kVideoTracks[0], stream); AddVideoTrack(kVideoTracks[0], stream.get());
} }
if (number_of_video_tracks > 1) { if (number_of_video_tracks > 1) {
sdp_ms1 += kSdpStringMs1Video1; sdp_ms1 += kSdpStringMs1Video1;
AddVideoTrack(kVideoTracks[1], stream); AddVideoTrack(kVideoTracks[1], stream.get());
} }
return std::unique_ptr<SessionDescriptionInterface>( return std::unique_ptr<SessionDescriptionInterface>(
@ -1140,7 +1143,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
MediaStreamInterface* stream) { MediaStreamInterface* stream) {
rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track( rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
webrtc::AudioTrack::Create(track_id, nullptr)); webrtc::AudioTrack::Create(track_id, nullptr));
ASSERT_TRUE(stream->AddTrack(audio_track)); ASSERT_TRUE(stream->AddTrack(audio_track.get()));
} }
void AddVideoTrack(const std::string& track_id, void AddVideoTrack(const std::string& track_id,
@ -1149,7 +1152,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
webrtc::VideoTrack::Create(track_id, webrtc::VideoTrack::Create(track_id,
webrtc::FakeVideoTrackSource::Create(), webrtc::FakeVideoTrackSource::Create(),
rtc::Thread::Current())); rtc::Thread::Current()));
ASSERT_TRUE(stream->AddTrack(video_track)); ASSERT_TRUE(stream->AddTrack(video_track.get()));
} }
std::unique_ptr<SessionDescriptionInterface> CreateOfferWithOneAudioTrack() { std::unique_ptr<SessionDescriptionInterface> CreateOfferWithOneAudioTrack() {
@ -1195,7 +1198,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
RTC_DCHECK(pc_); RTC_DCHECK(pc_);
auto observer = auto observer =
rtc::make_ref_counted<MockCreateSessionDescriptionObserver>(); rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
pc_->CreateOffer(observer, offer_answer_options); pc_->CreateOffer(observer.get(), offer_answer_options);
EXPECT_EQ_WAIT(true, observer->called(), kTimeout); EXPECT_EQ_WAIT(true, observer->called(), kTimeout);
return observer->MoveDescription(); return observer->MoveDescription();
} }
@ -1394,7 +1397,7 @@ TEST_P(PeerConnectionInterfaceTest,
auto result = pc_factory_->CreatePeerConnectionOrError( auto result = pc_factory_->CreatePeerConnectionOrError(
config, std::move(pc_dependencies)); config, std::move(pc_dependencies));
EXPECT_TRUE(result.ok()); EXPECT_TRUE(result.ok());
observer_.SetPeerConnectionInterface(result.value()); observer_.SetPeerConnectionInterface(result.value().get());
// Now validate that the config fields set above were applied to the // Now validate that the config fields set above were applied to the
// PortAllocator, as flags or otherwise. // PortAllocator, as flags or otherwise.
@ -1458,10 +1461,10 @@ TEST_F(PeerConnectionInterfaceTestPlanB, AddStreams) {
rtc::scoped_refptr<MediaStreamInterface> stream( rtc::scoped_refptr<MediaStreamInterface> stream(
pc_factory_->CreateLocalMediaStream(kStreamId3)); pc_factory_->CreateLocalMediaStream(kStreamId3));
rtc::scoped_refptr<AudioTrackInterface> audio_track( rtc::scoped_refptr<AudioTrackInterface> audio_track(
pc_factory_->CreateAudioTrack(kStreamId3, pc_factory_->CreateAudioTrack(
static_cast<AudioSourceInterface*>(NULL))); kStreamId3, static_cast<AudioSourceInterface*>(nullptr)));
stream->AddTrack(audio_track.get()); stream->AddTrack(audio_track.get());
EXPECT_TRUE(pc_->AddStream(stream)); EXPECT_TRUE(pc_->AddStream(stream.get()));
EXPECT_EQ(3u, pc_->local_streams()->count()); EXPECT_EQ(3u, pc_->local_streams()->count());
// Remove the third stream. // Remove the third stream.
@ -1824,7 +1827,7 @@ TEST_F(PeerConnectionInterfaceTestPlanB, RemoveTrackAfterAddStream) {
MediaStreamInterface* stream = pc_->local_streams()->at(0); MediaStreamInterface* stream = pc_->local_streams()->at(0);
// Remove the video track. // Remove the video track.
stream->RemoveTrack(stream->GetVideoTracks()[0]); stream->RemoveTrack(stream->GetVideoTracks()[0].get());
std::unique_ptr<SessionDescriptionInterface> offer; std::unique_ptr<SessionDescriptionInterface> offer;
ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
@ -1858,7 +1861,7 @@ TEST_P(PeerConnectionInterfaceTest, GetStatsForSpecificTrack) {
ASSERT_LT(0u, pc_->GetReceivers().size()); ASSERT_LT(0u, pc_->GetReceivers().size());
rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio = rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio =
pc_->GetReceivers()[0]->track(); pc_->GetReceivers()[0]->track();
EXPECT_TRUE(DoGetStats(remote_audio)); EXPECT_TRUE(DoGetStats(remote_audio.get()));
// Remove the stream. Since we are sending to our selves the local // Remove the stream. Since we are sending to our selves the local
// and the remote stream is the same. // and the remote stream is the same.
@ -1868,7 +1871,7 @@ TEST_P(PeerConnectionInterfaceTest, GetStatsForSpecificTrack) {
// Test that we still can get statistics for the old track. Even if it is not // Test that we still can get statistics for the old track. Even if it is not
// sent any longer. // sent any longer.
EXPECT_TRUE(DoGetStats(remote_audio)); EXPECT_TRUE(DoGetStats(remote_audio.get()));
} }
// Test that we can get stats on a video track. // Test that we can get stats on a video track.
@ -1876,15 +1879,15 @@ TEST_P(PeerConnectionInterfaceTest, GetStatsForVideoTrack) {
InitiateCall(); InitiateCall();
auto video_receiver = GetFirstReceiverOfType(cricket::MEDIA_TYPE_VIDEO); auto video_receiver = GetFirstReceiverOfType(cricket::MEDIA_TYPE_VIDEO);
ASSERT_TRUE(video_receiver); ASSERT_TRUE(video_receiver);
EXPECT_TRUE(DoGetStats(video_receiver->track())); EXPECT_TRUE(DoGetStats(video_receiver->track().get()));
} }
// Test that we don't get statistics for an invalid track. // Test that we don't get statistics for an invalid track.
TEST_P(PeerConnectionInterfaceTest, GetStatsForInvalidTrack) { TEST_P(PeerConnectionInterfaceTest, GetStatsForInvalidTrack) {
InitiateCall(); InitiateCall();
rtc::scoped_refptr<AudioTrackInterface> unknown_audio_track( rtc::scoped_refptr<AudioTrackInterface> unknown_audio_track(
pc_factory_->CreateAudioTrack("unknown track", NULL)); pc_factory_->CreateAudioTrack("unknown track", nullptr));
EXPECT_FALSE(DoGetStats(unknown_audio_track)); EXPECT_FALSE(DoGetStats(unknown_audio_track.get()));
} }
TEST_P(PeerConnectionInterfaceTest, GetRTCStatsBeforeAndAfterCalling) { TEST_P(PeerConnectionInterfaceTest, GetRTCStatsBeforeAndAfterCalling) {
@ -2048,22 +2051,22 @@ TEST_P(PeerConnectionInterfaceTest, ReceiveFireFoxOffer) {
webrtc::kFireFoxSdpOffer, nullptr)); webrtc::kFireFoxSdpOffer, nullptr));
EXPECT_TRUE(DoSetSessionDescription(std::move(desc), false)); EXPECT_TRUE(DoSetSessionDescription(std::move(desc), false));
CreateAnswerAsLocalDescription(); CreateAnswerAsLocalDescription();
ASSERT_TRUE(pc_->local_description() != NULL); ASSERT_TRUE(pc_->local_description() != nullptr);
ASSERT_TRUE(pc_->remote_description() != NULL); ASSERT_TRUE(pc_->remote_description() != nullptr);
const cricket::ContentInfo* content = const cricket::ContentInfo* content =
cricket::GetFirstAudioContent(pc_->local_description()->description()); cricket::GetFirstAudioContent(pc_->local_description()->description());
ASSERT_TRUE(content != NULL); ASSERT_TRUE(content != nullptr);
EXPECT_FALSE(content->rejected); EXPECT_FALSE(content->rejected);
content = content =
cricket::GetFirstVideoContent(pc_->local_description()->description()); cricket::GetFirstVideoContent(pc_->local_description()->description());
ASSERT_TRUE(content != NULL); ASSERT_TRUE(content != nullptr);
EXPECT_FALSE(content->rejected); EXPECT_FALSE(content->rejected);
#ifdef WEBRTC_HAVE_SCTP #ifdef WEBRTC_HAVE_SCTP
content = content =
cricket::GetFirstDataContent(pc_->local_description()->description()); cricket::GetFirstDataContent(pc_->local_description()->description());
ASSERT_TRUE(content != NULL); ASSERT_TRUE(content != nullptr);
EXPECT_FALSE(content->rejected); EXPECT_FALSE(content->rejected);
#endif #endif
} }
@ -2452,13 +2455,13 @@ TEST_F(PeerConnectionInterfaceTestPlanB, CloseAndTestMethods) {
pc_->Close(); pc_->Close();
pc_->RemoveStream(local_stream); pc_->RemoveStream(local_stream.get());
EXPECT_FALSE(pc_->AddStream(local_stream)); EXPECT_FALSE(pc_->AddStream(local_stream.get()));
EXPECT_FALSE(pc_->CreateDataChannelOrError("test", NULL).ok()); EXPECT_FALSE(pc_->CreateDataChannelOrError("test", NULL).ok());
EXPECT_TRUE(pc_->local_description() != NULL); EXPECT_TRUE(pc_->local_description() != nullptr);
EXPECT_TRUE(pc_->remote_description() != NULL); EXPECT_TRUE(pc_->remote_description() != nullptr);
std::unique_ptr<SessionDescriptionInterface> offer; std::unique_ptr<SessionDescriptionInterface> offer;
EXPECT_FALSE(DoCreateOffer(&offer, nullptr)); EXPECT_FALSE(DoCreateOffer(&offer, nullptr));
@ -2481,7 +2484,7 @@ TEST_F(PeerConnectionInterfaceTestPlanB, CloseAndTestMethods) {
TEST_P(PeerConnectionInterfaceTest, CloseAndGetStats) { TEST_P(PeerConnectionInterfaceTest, CloseAndGetStats) {
InitiateCall(); InitiateCall();
pc_->Close(); pc_->Close();
DoGetStats(NULL); DoGetStats(nullptr);
} }
// NOTE: The series of tests below come from what used to be // NOTE: The series of tests below come from what used to be
@ -2523,14 +2526,14 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
CreateSessionDescriptionAndReference(1, 1); CreateSessionDescriptionAndReference(1, 1);
EXPECT_TRUE(DoSetRemoteDescription(std::move(desc_ms1))); EXPECT_TRUE(DoSetRemoteDescription(std::move(desc_ms1)));
EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(), EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
reference_collection_)); reference_collection_.get()));
// Add extra audio and video tracks to the same MediaStream. // Add extra audio and video tracks to the same MediaStream.
std::unique_ptr<SessionDescriptionInterface> desc_ms1_two_tracks = std::unique_ptr<SessionDescriptionInterface> desc_ms1_two_tracks =
CreateSessionDescriptionAndReference(2, 2); CreateSessionDescriptionAndReference(2, 2);
EXPECT_TRUE(DoSetRemoteDescription(std::move(desc_ms1_two_tracks))); EXPECT_TRUE(DoSetRemoteDescription(std::move(desc_ms1_two_tracks)));
EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(), EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
reference_collection_)); reference_collection_.get()));
rtc::scoped_refptr<AudioTrackInterface> audio_track2 = rtc::scoped_refptr<AudioTrackInterface> audio_track2 =
observer_.remote_streams()->at(0)->GetAudioTracks()[1]; observer_.remote_streams()->at(0)->GetAudioTracks()[1];
EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, audio_track2->state()); EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, audio_track2->state());
@ -2541,14 +2544,14 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
// Remove the extra audio and video tracks. // Remove the extra audio and video tracks.
std::unique_ptr<SessionDescriptionInterface> desc_ms2 = std::unique_ptr<SessionDescriptionInterface> desc_ms2 =
CreateSessionDescriptionAndReference(1, 1); CreateSessionDescriptionAndReference(1, 1);
MockTrackObserver audio_track_observer(audio_track2); MockTrackObserver audio_track_observer(audio_track2.get());
MockTrackObserver video_track_observer(video_track2); MockTrackObserver video_track_observer(video_track2.get());
EXPECT_CALL(audio_track_observer, OnChanged()).Times(Exactly(1)); EXPECT_CALL(audio_track_observer, OnChanged()).Times(Exactly(1));
EXPECT_CALL(video_track_observer, OnChanged()).Times(Exactly(1)); EXPECT_CALL(video_track_observer, OnChanged()).Times(Exactly(1));
EXPECT_TRUE(DoSetRemoteDescription(std::move(desc_ms2))); EXPECT_TRUE(DoSetRemoteDescription(std::move(desc_ms2)));
EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(), EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
reference_collection_)); reference_collection_.get()));
// Track state may be updated asynchronously. // Track state may be updated asynchronously.
EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded, EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded,
audio_track2->state(), kTimeout); audio_track2->state(), kTimeout);
@ -2611,8 +2614,8 @@ TEST_F(PeerConnectionInterfaceTestPlanB, RemoveTrackThenRejectMediaContent) {
CreatePeerConnection(config); CreatePeerConnection(config);
CreateAndSetRemoteOffer(GetSdpStringWithStream1()); CreateAndSetRemoteOffer(GetSdpStringWithStream1());
MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0); MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0]); remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0].get());
remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]); remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0].get());
std::unique_ptr<SessionDescriptionInterface> local_answer( std::unique_ptr<SessionDescriptionInterface> local_answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, webrtc::CreateSessionDescription(SdpType::kAnswer,
@ -2696,8 +2699,8 @@ TEST_F(PeerConnectionInterfaceTestPlanB, RemoveAlreadyGoneRemoteStream) {
CreatePeerConnection(config); CreatePeerConnection(config);
CreateAndSetRemoteOffer(GetSdpStringWithStream1()); CreateAndSetRemoteOffer(GetSdpStringWithStream1());
MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0); MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]); remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0].get());
remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0]); remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0].get());
CreateAndSetRemoteOffer(kSdpStringWithoutStreams); CreateAndSetRemoteOffer(kSdpStringWithoutStreams);
@ -2918,7 +2921,7 @@ TEST_P(PeerConnectionInterfaceTest,
// Change the ssrc of the audio and video track. // Change the ssrc of the audio and video track.
cricket::MediaContentDescription* desc = cricket::MediaContentDescription* desc =
cricket::GetFirstAudioContentDescription(modified_offer->description()); cricket::GetFirstAudioContentDescription(modified_offer->description());
ASSERT_TRUE(desc != NULL); ASSERT_TRUE(desc != nullptr);
for (StreamParams& stream : desc->mutable_streams()) { for (StreamParams& stream : desc->mutable_streams()) {
for (unsigned int& ssrc : stream.ssrcs) { for (unsigned int& ssrc : stream.ssrcs) {
++ssrc; ++ssrc;
@ -2927,7 +2930,7 @@ TEST_P(PeerConnectionInterfaceTest,
desc = desc =
cricket::GetFirstVideoContentDescription(modified_offer->description()); cricket::GetFirstVideoContentDescription(modified_offer->description());
ASSERT_TRUE(desc != NULL); ASSERT_TRUE(desc != nullptr);
for (StreamParams& stream : desc->mutable_streams()) { for (StreamParams& stream : desc->mutable_streams()) {
for (unsigned int& ssrc : stream.ssrcs) { for (unsigned int& ssrc : stream.ssrcs) {
++ssrc; ++ssrc;
@ -2966,9 +2969,9 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
// Add a new MediaStream but with the same tracks as in the first stream. // Add a new MediaStream but with the same tracks as in the first stream.
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream_1( rtc::scoped_refptr<webrtc::MediaStreamInterface> stream_1(
webrtc::MediaStream::Create(kStreams[1])); webrtc::MediaStream::Create(kStreams[1]));
stream_1->AddTrack(stream_collection->at(0)->GetVideoTracks()[0]); stream_1->AddTrack(stream_collection->at(0)->GetVideoTracks()[0].get());
stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0]); stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0].get());
pc_->AddStream(stream_1); pc_->AddStream(stream_1.get());
ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
EXPECT_TRUE(DoSetLocalDescription(std::move(offer))); EXPECT_TRUE(DoSetLocalDescription(std::move(offer)));
@ -3576,27 +3579,27 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
CreatePeerConnectionWithoutDtls(); CreatePeerConnectionWithoutDtls();
rtc::scoped_refptr<MediaStreamInterface> stream( rtc::scoped_refptr<MediaStreamInterface> stream(
pc_factory_->CreateLocalMediaStream(kStreamId1)); pc_factory_->CreateLocalMediaStream(kStreamId1));
pc_->AddStream(stream); pc_->AddStream(stream.get());
rtc::scoped_refptr<AudioTrackInterface> audio_track( rtc::scoped_refptr<AudioTrackInterface> audio_track(
CreateAudioTrack("audio_track")); CreateAudioTrack("audio_track"));
rtc::scoped_refptr<VideoTrackInterface> video_track( rtc::scoped_refptr<VideoTrackInterface> video_track(
CreateVideoTrack("video_track")); CreateVideoTrack("video_track"));
stream->AddTrack(audio_track); stream->AddTrack(audio_track.get());
EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout); EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
observer_.renegotiation_needed_ = false; observer_.renegotiation_needed_ = false;
CreateOfferReceiveAnswer(); CreateOfferReceiveAnswer();
stream->AddTrack(video_track); stream->AddTrack(video_track.get());
EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout); EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
observer_.renegotiation_needed_ = false; observer_.renegotiation_needed_ = false;
CreateOfferReceiveAnswer(); CreateOfferReceiveAnswer();
stream->RemoveTrack(audio_track); stream->RemoveTrack(audio_track.get());
EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout); EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
observer_.renegotiation_needed_ = false; observer_.renegotiation_needed_ = false;
CreateOfferReceiveAnswer(); CreateOfferReceiveAnswer();
stream->RemoveTrack(video_track); stream->RemoveTrack(video_track.get());
EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout); EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
observer_.renegotiation_needed_ = false; observer_.renegotiation_needed_ = false;
} }
@ -3663,7 +3666,7 @@ class PeerConnectionMediaConfigTest : public ::testing::Test {
auto result = auto result =
pcf_->CreatePeerConnectionOrError(config, std::move(pc_dependencies)); pcf_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
EXPECT_TRUE(result.ok()); EXPECT_TRUE(result.ok());
observer_.SetPeerConnectionInterface(result.value()); observer_.SetPeerConnectionInterface(result.value().get());
return result.value()->GetConfiguration().media_config; return result.value()->GetConfiguration().media_config;
} }
@ -3679,7 +3682,7 @@ TEST_F(PeerConnectionMediaConfigTest, TestCreateAndClose) {
auto result = auto result =
pcf_->CreatePeerConnectionOrError(config, std::move(pc_dependencies)); pcf_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
EXPECT_TRUE(result.ok()); EXPECT_TRUE(result.ok());
observer_.SetPeerConnectionInterface(result.value()); observer_.SetPeerConnectionInterface(result.value().get());
result.value()->Close(); // No abort -> ok. result.value()->Close(); // No abort -> ok.
SUCCEED(); SUCCEED();
} }

4
pc/peer_connection_jsep_unittest.cc
View File

@ -123,7 +123,7 @@ class PeerConnectionJsepTest : public ::testing::Test {
return nullptr; return nullptr;
} }
observer->SetPeerConnectionInterface(result.value()); observer->SetPeerConnectionInterface(result.value().get());
return std::make_unique<PeerConnectionWrapper>( return std::make_unique<PeerConnectionWrapper>(
pc_factory, result.MoveValue(), std::move(observer)); pc_factory, result.MoveValue(), std::move(observer));
} }
@ -1363,7 +1363,7 @@ TEST_F(PeerConnectionJsepTest,
auto caller = CreatePeerConnection(); auto caller = CreatePeerConnection();
auto transceiver = caller->AddTransceiver(cricket::MEDIA_TYPE_AUDIO); auto transceiver = caller->AddTransceiver(cricket::MEDIA_TYPE_AUDIO);
transceiver->sender()->SetTrack(caller->CreateAudioTrack(kTrackId)); transceiver->sender()->SetTrack(caller->CreateAudioTrack(kTrackId).get());
auto offer = caller->CreateOffer(); auto offer = caller->CreateOffer();
auto contents = offer->description()->contents(); auto contents = offer->description()->contents();

2
pc/peer_connection_message_handler.cc
View File

@ -117,7 +117,7 @@ void PeerConnectionMessageHandler::OnMessage(rtc::Message* msg) {
case MSG_GETSTATS: { case MSG_GETSTATS: {
GetStatsMsg* param = static_cast<GetStatsMsg*>(msg->pdata); GetStatsMsg* param = static_cast<GetStatsMsg*>(msg->pdata);
StatsReports reports; StatsReports reports;
param->stats->GetStats(param->track, &reports); param->stats->GetStats(param->track.get(), &reports);
param->observer->OnComplete(reports); param->observer->OnComplete(reports);
delete param; delete param;
break; break;

5
pc/peer_connection_rampup_tests.cc
View File

@ -123,14 +123,15 @@ class PeerConnectionWrapperForRampUpTest : public PeerConnectionWrapper {
video_track_sources_.back()->Start(); video_track_sources_.back()->Start();
return rtc::scoped_refptr<VideoTrackInterface>( return rtc::scoped_refptr<VideoTrackInterface>(
pc_factory()->CreateVideoTrack(rtc::CreateRandomUuid(), pc_factory()->CreateVideoTrack(rtc::CreateRandomUuid(),
video_track_sources_.back())); video_track_sources_.back().get()));
} }
rtc::scoped_refptr<AudioTrackInterface> CreateLocalAudioTrack( rtc::scoped_refptr<AudioTrackInterface> CreateLocalAudioTrack(
const cricket::AudioOptions options) { const cricket::AudioOptions options) {
rtc::scoped_refptr<AudioSourceInterface> source = rtc::scoped_refptr<AudioSourceInterface> source =
pc_factory()->CreateAudioSource(options); pc_factory()->CreateAudioSource(options);
return pc_factory()->CreateAudioTrack(rtc::CreateRandomUuid(), source); return pc_factory()->CreateAudioTrack(rtc::CreateRandomUuid(),
source.get());
} }
private: private:

6
pc/peer_connection_rtp_unittest.cc
View File

@ -138,7 +138,7 @@ class PeerConnectionRtpBaseTest : public ::testing::Test {
auto result = pc_factory_->CreatePeerConnectionOrError( auto result = pc_factory_->CreatePeerConnectionOrError(
config, PeerConnectionDependencies(observer.get())); config, PeerConnectionDependencies(observer.get()));
EXPECT_TRUE(result.ok()); EXPECT_TRUE(result.ok());
observer->SetPeerConnectionInterface(result.value()); observer->SetPeerConnectionInterface(result.value().get());
return std::make_unique<PeerConnectionWrapper>( return std::make_unique<PeerConnectionWrapper>(
pc_factory_, result.MoveValue(), std::move(observer)); pc_factory_, result.MoveValue(), std::move(observer));
} }
@ -921,7 +921,7 @@ TEST_P(PeerConnectionRtpTest,
rtc::make_ref_counted<webrtc::MockSetSessionDescriptionObserver>(); rtc::make_ref_counted<webrtc::MockSetSessionDescriptionObserver>();
auto offer = caller->CreateOfferAndSetAsLocal(); auto offer = caller->CreateOfferAndSetAsLocal();
callee->pc()->SetRemoteDescription(observer, offer.release()); callee->pc()->SetRemoteDescription(observer.get(), offer.release());
callee = nullptr; callee = nullptr;
rtc::Thread::Current()->ProcessMessages(0); rtc::Thread::Current()->ProcessMessages(0);
EXPECT_FALSE(observer->called()); EXPECT_FALSE(observer->called());
@ -1989,7 +1989,7 @@ TEST_P(PeerConnectionRtpTest, CreateTwoSendersWithSameTrack) {
EXPECT_TRUE(sender1->SetTrack(nullptr)); EXPECT_TRUE(sender1->SetTrack(nullptr));
auto sender2 = caller->AddTrack(track); auto sender2 = caller->AddTrack(track);
EXPECT_TRUE(sender2); EXPECT_TRUE(sender2);
EXPECT_TRUE(sender1->SetTrack(track)); EXPECT_TRUE(sender1->SetTrack(track.get()));
if (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED) { if (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED) {
// TODO(hbos): When https://crbug.com/webrtc/8734 is resolved, this should // TODO(hbos): When https://crbug.com/webrtc/8734 is resolved, this should

23
pc/peer_connection_signaling_unittest.cc
View File

@ -153,7 +153,7 @@ class PeerConnectionSignalingBaseTest : public ::testing::Test {
return nullptr; return nullptr;
} }
observer->SetPeerConnectionInterface(result.value()); observer->SetPeerConnectionInterface(result.value().get());
return std::make_unique<PeerConnectionWrapperForSignalingTest>( return std::make_unique<PeerConnectionWrapperForSignalingTest>(
pc_factory_, result.MoveValue(), std::move(observer)); pc_factory_, result.MoveValue(), std::move(observer));
} }
@ -571,7 +571,7 @@ TEST_P(PeerConnectionSignalingTest, CreateOffersAndShutdown) {
rtc::scoped_refptr<MockCreateSessionDescriptionObserver> observers[100]; rtc::scoped_refptr<MockCreateSessionDescriptionObserver> observers[100];
for (auto& observer : observers) { for (auto& observer : observers) {
observer = rtc::make_ref_counted<MockCreateSessionDescriptionObserver>(); observer = rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
caller->pc()->CreateOffer(observer, options); caller->pc()->CreateOffer(observer.get(), options);
} }
// Destroy the PeerConnection. // Destroy the PeerConnection.
@ -593,7 +593,7 @@ TEST_P(PeerConnectionSignalingTest, CloseCreateOfferAndShutdown) {
auto caller = CreatePeerConnection(); auto caller = CreatePeerConnection();
auto observer = rtc::make_ref_counted<MockCreateSessionDescriptionObserver>(); auto observer = rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
caller->pc()->Close(); caller->pc()->Close();
caller->pc()->CreateOffer(observer, RTCOfferAnswerOptions()); caller->pc()->CreateOffer(observer.get(), RTCOfferAnswerOptions());
caller.reset(nullptr); caller.reset(nullptr);
EXPECT_TRUE(observer->called()); EXPECT_TRUE(observer->called());
} }
@ -680,7 +680,7 @@ TEST_P(PeerConnectionSignalingTest,
auto offer = caller->CreateOffer(RTCOfferAnswerOptions()); auto offer = caller->CreateOffer(RTCOfferAnswerOptions());
auto observer = MockSetSessionDescriptionObserver::Create(); auto observer = MockSetSessionDescriptionObserver::Create();
caller->pc()->SetLocalDescription(observer, offer.release()); caller->pc()->SetLocalDescription(observer.get(), offer.release());
// The old observer is not invoked immediately. // The old observer is not invoked immediately.
EXPECT_FALSE(observer->called()); EXPECT_FALSE(observer->called());
// Process all currently pending messages by waiting for a posted task to run. // Process all currently pending messages by waiting for a posted task to run.
@ -720,7 +720,7 @@ TEST_P(PeerConnectionSignalingTest, CreateOfferBlocksSetRemoteDescription) {
// Synchronously invoke CreateOffer() and SetRemoteDescription(). The // Synchronously invoke CreateOffer() and SetRemoteDescription(). The
// SetRemoteDescription() operation should be chained to be executed // SetRemoteDescription() operation should be chained to be executed
// asynchronously, when CreateOffer() completes. // asynchronously, when CreateOffer() completes.
callee->pc()->CreateOffer(offer_observer, RTCOfferAnswerOptions()); callee->pc()->CreateOffer(offer_observer.get(), RTCOfferAnswerOptions());
callee->pc()->SetRemoteDescription( callee->pc()->SetRemoteDescription(
std::move(offer), std::move(offer),
rtc::make_ref_counted<FakeSetRemoteDescriptionObserver>()); rtc::make_ref_counted<FakeSetRemoteDescriptionObserver>());
@ -802,7 +802,7 @@ TEST_P(PeerConnectionSignalingTest,
auto callee_set_remote_description_observer = auto callee_set_remote_description_observer =
MockSetSessionDescriptionObserver::Create(); MockSetSessionDescriptionObserver::Create();
callee->pc()->SetRemoteDescription( callee->pc()->SetRemoteDescription(
callee_set_remote_description_observer, callee_set_remote_description_observer.get(),
CloneSessionDescription(caller->pc()->pending_local_description()) CloneSessionDescription(caller->pc()->pending_local_description())
.release()); .release());
@ -822,7 +822,7 @@ TEST_P(PeerConnectionSignalingTest,
auto caller_set_remote_description_observer = auto caller_set_remote_description_observer =
MockSetSessionDescriptionObserver::Create(); MockSetSessionDescriptionObserver::Create();
caller->pc()->SetRemoteDescription( caller->pc()->SetRemoteDescription(
caller_set_remote_description_observer, caller_set_remote_description_observer.get(),
CloneSessionDescription(callee->pc()->current_local_description()) CloneSessionDescription(callee->pc()->current_local_description())
.release()); .release());
EXPECT_TRUE_WAIT(caller_set_remote_description_observer->called(), EXPECT_TRUE_WAIT(caller_set_remote_description_observer->called(),
@ -1126,7 +1126,7 @@ TEST_F(PeerConnectionSignalingUnifiedPlanTest,
// waiting for it would not ensure synchronicity. // waiting for it would not ensure synchronicity.
RTC_DCHECK(!caller->pc()->GetTransceivers()[0]->mid().has_value()); RTC_DCHECK(!caller->pc()->GetTransceivers()[0]->mid().has_value());
caller->pc()->SetLocalDescription( caller->pc()->SetLocalDescription(
rtc::make_ref_counted<MockSetSessionDescriptionObserver>(), rtc::make_ref_counted<MockSetSessionDescriptionObserver>().get(),
offer.release()); offer.release());
EXPECT_TRUE(caller->pc()->GetTransceivers()[0]->mid().has_value()); EXPECT_TRUE(caller->pc()->GetTransceivers()[0]->mid().has_value());
} }
@ -1162,11 +1162,12 @@ TEST_F(PeerConnectionSignalingUnifiedPlanTest,
// operation executed immediately. // operation executed immediately.
RTC_DCHECK(!pc->GetTransceivers()[0]->mid().has_value()); RTC_DCHECK(!pc->GetTransceivers()[0]->mid().has_value());
pc->SetLocalDescription( pc->SetLocalDescription(
rtc::make_ref_counted<MockSetSessionDescriptionObserver>(), rtc::make_ref_counted<MockSetSessionDescriptionObserver>()
.get(),
desc); desc);
EXPECT_TRUE(pc->GetTransceivers()[0]->mid().has_value()); EXPECT_TRUE(pc->GetTransceivers()[0]->mid().has_value());
}); });
caller->pc()->CreateOffer(offer_observer, RTCOfferAnswerOptions()); caller->pc()->CreateOffer(offer_observer.get(), RTCOfferAnswerOptions());
EXPECT_TRUE_WAIT(offer_observer->was_called(), kWaitTimeout); EXPECT_TRUE_WAIT(offer_observer->was_called(), kWaitTimeout);
} }
@ -1253,7 +1254,7 @@ TEST_F(PeerConnectionSignalingUnifiedPlanTest,
EXPECT_TRUE(caller->observer()->has_negotiation_needed_event()); EXPECT_TRUE(caller->observer()->has_negotiation_needed_event());
auto observer = rtc::make_ref_counted<MockCreateSessionDescriptionObserver>(); auto observer = rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
caller->pc()->CreateOffer(observer, RTCOfferAnswerOptions()); caller->pc()->CreateOffer(observer.get(), RTCOfferAnswerOptions());
// For this test to work, the operation has to be pending, i.e. the observer // For this test to work, the operation has to be pending, i.e. the observer
// has not yet been invoked. // has not yet been invoked.
EXPECT_FALSE(observer->called()); EXPECT_FALSE(observer->called());

2
pc/peer_connection_simulcast_unittest.cc
View File

@ -140,7 +140,7 @@ class PeerConnectionSimulcastTests : public ::testing::Test {
auto result = auto result =
pc_factory_->CreatePeerConnectionOrError(config, std::move(pcd)); pc_factory_->CreatePeerConnectionOrError(config, std::move(pcd));
EXPECT_TRUE(result.ok()); EXPECT_TRUE(result.ok());
observer->SetPeerConnectionInterface(result.value()); observer->SetPeerConnectionInterface(result.value().get());
return result.MoveValue(); return result.MoveValue();
} }

9
pc/peer_connection_wrapper.cc
View File

@ -135,7 +135,7 @@ std::unique_ptr<SessionDescriptionInterface> PeerConnectionWrapper::CreateSdp(
rtc::FunctionView<void(CreateSessionDescriptionObserver*)> fn, rtc::FunctionView<void(CreateSessionDescriptionObserver*)> fn,
std::string* error_out) { std::string* error_out) {
auto observer = rtc::make_ref_counted<MockCreateSessionDescriptionObserver>(); auto observer = rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
fn(observer); fn(observer.get());
EXPECT_EQ_WAIT(true, observer->called(), kDefaultTimeout); EXPECT_EQ_WAIT(true, observer->called(), kDefaultTimeout);
if (error_out && !observer->result()) { if (error_out && !observer->result()) {
*error_out = observer->error(); *error_out = observer->error();
@ -179,7 +179,7 @@ bool PeerConnectionWrapper::SetSdp(
rtc::FunctionView<void(SetSessionDescriptionObserver*)> fn, rtc::FunctionView<void(SetSessionDescriptionObserver*)> fn,
std::string* error_out) { std::string* error_out) {
auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>(); auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
fn(observer); fn(observer.get());
EXPECT_EQ_WAIT(true, observer->called(), kDefaultTimeout); EXPECT_EQ_WAIT(true, observer->called(), kDefaultTimeout);
if (error_out && !observer->result()) { if (error_out && !observer->result()) {
*error_out = observer->error(); *error_out = observer->error();
@ -277,7 +277,8 @@ rtc::scoped_refptr<AudioTrackInterface> PeerConnectionWrapper::CreateAudioTrack(
rtc::scoped_refptr<VideoTrackInterface> PeerConnectionWrapper::CreateVideoTrack( rtc::scoped_refptr<VideoTrackInterface> PeerConnectionWrapper::CreateVideoTrack(
const std::string& label) { const std::string& label) {
return pc_factory()->CreateVideoTrack(label, FakeVideoTrackSource::Create()); return pc_factory()->CreateVideoTrack(label,
FakeVideoTrackSource::Create().get());
} }
rtc::scoped_refptr<RtpSenderInterface> PeerConnectionWrapper::AddTrack( rtc::scoped_refptr<RtpSenderInterface> PeerConnectionWrapper::AddTrack(
@ -329,7 +330,7 @@ bool PeerConnectionWrapper::IsIceConnected() {
rtc::scoped_refptr<const webrtc::RTCStatsReport> rtc::scoped_refptr<const webrtc::RTCStatsReport>
PeerConnectionWrapper::GetStats() { PeerConnectionWrapper::GetStats() {
auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>(); auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>();
pc()->GetStats(callback); pc()->GetStats(callback.get());
EXPECT_TRUE_WAIT(callback->called(), kDefaultTimeout); EXPECT_TRUE_WAIT(callback->called(), kDefaultTimeout);
return callback->report(); return callback->report();
} }

12
pc/rtc_stats_collector.cc
View File

@ -1893,7 +1893,8 @@ void RTCStatsCollector::ProduceAudioRTPStreamStats_n(
inbound_audio->track_id = inbound_audio->track_id =
RTCMediaStreamTrackStatsIDFromDirectionAndAttachment( RTCMediaStreamTrackStatsIDFromDirectionAndAttachment(
kReceiver, kReceiver,
track_media_info_map.GetAttachmentIdByTrack(audio_track).value()); track_media_info_map.GetAttachmentIdByTrack(audio_track.get())
.value());
} }
inbound_audio->transport_id = transport_id; inbound_audio->transport_id = transport_id;
// Remote-outbound. // Remote-outbound.
@ -1924,7 +1925,8 @@ void RTCStatsCollector::ProduceAudioRTPStreamStats_n(
track_media_info_map.GetAudioTrack(voice_sender_info); track_media_info_map.GetAudioTrack(voice_sender_info);
if (audio_track) { if (audio_track) {
int attachment_id = int attachment_id =
track_media_info_map.GetAttachmentIdByTrack(audio_track).value(); track_media_info_map.GetAttachmentIdByTrack(audio_track.get())
.value();
outbound_audio->track_id = outbound_audio->track_id =
RTCMediaStreamTrackStatsIDFromDirectionAndAttachment(kSender, RTCMediaStreamTrackStatsIDFromDirectionAndAttachment(kSender,
attachment_id); attachment_id);
@ -1985,7 +1987,8 @@ void RTCStatsCollector::ProduceVideoRTPStreamStats_n(
inbound_video->track_id = inbound_video->track_id =
RTCMediaStreamTrackStatsIDFromDirectionAndAttachment( RTCMediaStreamTrackStatsIDFromDirectionAndAttachment(
kReceiver, kReceiver,
track_media_info_map.GetAttachmentIdByTrack(video_track).value()); track_media_info_map.GetAttachmentIdByTrack(video_track.get())
.value());
} }
inbound_video->transport_id = transport_id; inbound_video->transport_id = transport_id;
report->AddStats(std::move(inbound_video)); report->AddStats(std::move(inbound_video));
@ -2007,7 +2010,8 @@ void RTCStatsCollector::ProduceVideoRTPStreamStats_n(
track_media_info_map.GetVideoTrack(video_sender_info); track_media_info_map.GetVideoTrack(video_sender_info);
if (video_track) { if (video_track) {
int attachment_id = int attachment_id =
track_media_info_map.GetAttachmentIdByTrack(video_track).value(); track_media_info_map.GetAttachmentIdByTrack(video_track.get())
.value();
outbound_video->track_id = outbound_video->track_id =
RTCMediaStreamTrackStatsIDFromDirectionAndAttachment(kSender, RTCMediaStreamTrackStatsIDFromDirectionAndAttachment(kSender,
attachment_id); attachment_id);

45
pc/rtc_stats_collector_unittest.cc
View File

@ -427,8 +427,8 @@ class RTCStatsCollectorWrapper {
rtc::scoped_refptr<FakePeerConnectionForStats> pc) rtc::scoped_refptr<FakePeerConnectionForStats> pc)
: pc_(pc), : pc_(pc),
stats_collector_( stats_collector_(
RTCStatsCollector::Create(pc, 50 * rtc::kNumMicrosecsPerMillisec)) { RTCStatsCollector::Create(pc.get(),
} 50 * rtc::kNumMicrosecsPerMillisec)) {}
rtc::scoped_refptr<RTCStatsCollector> stats_collector() { rtc::scoped_refptr<RTCStatsCollector> stats_collector() {
return stats_collector_; return stats_collector_;
@ -631,7 +631,7 @@ class RTCStatsCollectorWrapper {
private: private:
rtc::scoped_refptr<const RTCStatsReport> WaitForReport( rtc::scoped_refptr<const RTCStatsReport> WaitForReport(
rtc::scoped_refptr<RTCStatsObtainer> callback) { rtc::scoped_refptr<RTCStatsObtainer> callback) {
EXPECT_TRUE_WAIT(callback->report(), kGetStatsReportTimeoutMs); EXPECT_TRUE_WAIT(callback->report() != nullptr, kGetStatsReportTimeoutMs);
int64_t after = rtc::TimeUTCMicros(); int64_t after = rtc::TimeUTCMicros();
for (const RTCStats& stats : *callback->report()) { for (const RTCStats& stats : *callback->report()) {
if (stats.type() == RTCRemoteInboundRtpStreamStats::kType || if (stats.type() == RTCRemoteInboundRtpStreamStats::kType ||
@ -920,7 +920,7 @@ class RTCStatsCollectorTest : public ::testing::Test {
TEST_F(RTCStatsCollectorTest, SingleCallback) { TEST_F(RTCStatsCollectorTest, SingleCallback) {
rtc::scoped_refptr<const RTCStatsReport> result; rtc::scoped_refptr<const RTCStatsReport> result;
stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&result)); stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&result));
EXPECT_TRUE_WAIT(result, kGetStatsReportTimeoutMs); EXPECT_TRUE_WAIT(result != nullptr, kGetStatsReportTimeoutMs);
} }
TEST_F(RTCStatsCollectorTest, MultipleCallbacks) { TEST_F(RTCStatsCollectorTest, MultipleCallbacks) {
@ -928,9 +928,9 @@ TEST_F(RTCStatsCollectorTest, MultipleCallbacks) {
stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&a)); stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&a));
stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&b)); stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&b));
stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&c)); stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&c));
EXPECT_TRUE_WAIT(a, kGetStatsReportTimeoutMs); EXPECT_TRUE_WAIT(a != nullptr, kGetStatsReportTimeoutMs);
EXPECT_TRUE_WAIT(b, kGetStatsReportTimeoutMs); EXPECT_TRUE_WAIT(b != nullptr, kGetStatsReportTimeoutMs);
EXPECT_TRUE_WAIT(c, kGetStatsReportTimeoutMs); EXPECT_TRUE_WAIT(c != nullptr, kGetStatsReportTimeoutMs);
EXPECT_EQ(a.get(), b.get()); EXPECT_EQ(a.get(), b.get());
EXPECT_EQ(b.get(), c.get()); EXPECT_EQ(b.get(), c.get());
@ -959,9 +959,9 @@ TEST_F(RTCStatsCollectorTest, MultipleCallbacksWithInvalidatedCacheInBetween) {
// Cache is invalidated after 50 ms. // Cache is invalidated after 50 ms.
fake_clock_.AdvanceTime(TimeDelta::Millis(51)); fake_clock_.AdvanceTime(TimeDelta::Millis(51));
stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&c)); stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&c));
EXPECT_TRUE_WAIT(a, kGetStatsReportTimeoutMs); EXPECT_TRUE_WAIT(a != nullptr, kGetStatsReportTimeoutMs);
EXPECT_TRUE_WAIT(b, kGetStatsReportTimeoutMs); EXPECT_TRUE_WAIT(b != nullptr, kGetStatsReportTimeoutMs);
EXPECT_TRUE_WAIT(c, kGetStatsReportTimeoutMs); EXPECT_TRUE_WAIT(c != nullptr, kGetStatsReportTimeoutMs);
EXPECT_EQ(a.get(), b.get()); EXPECT_EQ(a.get(), b.get());
// The act of doing `AdvanceTime` processes all messages. If this was not the // The act of doing `AdvanceTime` processes all messages. If this was not the
// case we might not require `c` to be fresher than `b`. // case we might not require `c` to be fresher than `b`.
@ -1748,10 +1748,10 @@ TEST_F(RTCStatsCollectorTest,
rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport(); rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCMediaStreamStats expected_local_stream( RTCMediaStreamStats expected_local_stream(
IdForType<RTCMediaStreamStats>(report), report->timestamp_us()); IdForType<RTCMediaStreamStats>(report.get()), report->timestamp_us());
expected_local_stream.stream_identifier = local_stream->id(); expected_local_stream.stream_identifier = local_stream->id();
expected_local_stream.track_ids = { expected_local_stream.track_ids = {
IdForType<RTCMediaStreamTrackStats>(report)}; IdForType<RTCMediaStreamTrackStats>(report.get())};
ASSERT_TRUE(report->Get(expected_local_stream.id())) ASSERT_TRUE(report->Get(expected_local_stream.id()))
<< "Did not find " << expected_local_stream.id() << " in " << "Did not find " << expected_local_stream.id() << " in "
<< report->ToJson(); << report->ToJson();
@ -1760,7 +1760,7 @@ TEST_F(RTCStatsCollectorTest,
report->Get(expected_local_stream.id())->cast_to<RTCMediaStreamStats>()); report->Get(expected_local_stream.id())->cast_to<RTCMediaStreamStats>());
RTCMediaStreamTrackStats expected_local_audio_track_ssrc1( RTCMediaStreamTrackStats expected_local_audio_track_ssrc1(
IdForType<RTCMediaStreamTrackStats>(report), report->timestamp_us(), IdForType<RTCMediaStreamTrackStats>(report.get()), report->timestamp_us(),
RTCMediaStreamTrackKind::kAudio); RTCMediaStreamTrackKind::kAudio);
expected_local_audio_track_ssrc1.track_identifier = local_audio_track->id(); expected_local_audio_track_ssrc1.track_identifier = local_audio_track->id();
expected_local_audio_track_ssrc1.media_source_id = expected_local_audio_track_ssrc1.media_source_id =
@ -1819,10 +1819,10 @@ TEST_F(RTCStatsCollectorTest,
rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport(); rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCMediaStreamStats expected_remote_stream( RTCMediaStreamStats expected_remote_stream(
IdForType<RTCMediaStreamStats>(report), report->timestamp_us()); IdForType<RTCMediaStreamStats>(report.get()), report->timestamp_us());
expected_remote_stream.stream_identifier = remote_stream->id(); expected_remote_stream.stream_identifier = remote_stream->id();
expected_remote_stream.track_ids = expected_remote_stream.track_ids = std::vector<std::string>(
std::vector<std::string>({IdForType<RTCMediaStreamTrackStats>(report)}); {IdForType<RTCMediaStreamTrackStats>(report.get())});
ASSERT_TRUE(report->Get(expected_remote_stream.id())) ASSERT_TRUE(report->Get(expected_remote_stream.id()))
<< "Did not find " << expected_remote_stream.id() << " in " << "Did not find " << expected_remote_stream.id() << " in "
<< report->ToJson(); << report->ToJson();
@ -1831,7 +1831,7 @@ TEST_F(RTCStatsCollectorTest,
report->Get(expected_remote_stream.id())->cast_to<RTCMediaStreamStats>()); report->Get(expected_remote_stream.id())->cast_to<RTCMediaStreamStats>());
RTCMediaStreamTrackStats expected_remote_audio_track( RTCMediaStreamTrackStats expected_remote_audio_track(
IdForType<RTCMediaStreamTrackStats>(report), report->timestamp_us(), IdForType<RTCMediaStreamTrackStats>(report.get()), report->timestamp_us(),
RTCMediaStreamTrackKind::kAudio); RTCMediaStreamTrackKind::kAudio);
expected_remote_audio_track.track_identifier = remote_audio_track->id(); expected_remote_audio_track.track_identifier = remote_audio_track->id();
// `expected_remote_audio_track.media_source_id` should be undefined // `expected_remote_audio_track.media_source_id` should be undefined
@ -2168,7 +2168,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Video) {
expected_video.ssrc = 1; expected_video.ssrc = 1;
expected_video.media_type = "video"; expected_video.media_type = "video";
expected_video.kind = "video"; expected_video.kind = "video";
expected_video.track_id = IdForType<RTCMediaStreamTrackStats>(report); expected_video.track_id = IdForType<RTCMediaStreamTrackStats>(report.get());
expected_video.transport_id = "RTCTransport_TransportName_1"; expected_video.transport_id = "RTCTransport_TransportName_1";
expected_video.codec_id = "RTCCodec_VideoMid_Inbound_42"; expected_video.codec_id = "RTCCodec_VideoMid_Inbound_42";
expected_video.fir_count = 5; expected_video.fir_count = 5;
@ -2259,7 +2259,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Audio) {
expected_audio.ssrc = 1; expected_audio.ssrc = 1;
expected_audio.media_type = "audio"; expected_audio.media_type = "audio";
expected_audio.kind = "audio"; expected_audio.kind = "audio";
expected_audio.track_id = IdForType<RTCMediaStreamTrackStats>(report); expected_audio.track_id = IdForType<RTCMediaStreamTrackStats>(report.get());
expected_audio.transport_id = "RTCTransport_TransportName_1"; expected_audio.transport_id = "RTCTransport_TransportName_1";
expected_audio.codec_id = "RTCCodec_AudioMid_Outbound_42"; expected_audio.codec_id = "RTCCodec_AudioMid_Outbound_42";
expected_audio.packets_sent = 2; expected_audio.packets_sent = 2;
@ -2661,7 +2661,7 @@ TEST_F(RTCStatsCollectorTest, CollectNoStreamRTCOutboundRTPStreamStats_Audio) {
expected_audio.ssrc = 1; expected_audio.ssrc = 1;
expected_audio.media_type = "audio"; expected_audio.media_type = "audio";
expected_audio.kind = "audio"; expected_audio.kind = "audio";
expected_audio.track_id = IdForType<RTCMediaStreamTrackStats>(report); expected_audio.track_id = IdForType<RTCMediaStreamTrackStats>(report.get());
expected_audio.transport_id = "RTCTransport_TransportName_1"; expected_audio.transport_id = "RTCTransport_TransportName_1";
expected_audio.codec_id = "RTCCodec_AudioMid_Outbound_42"; expected_audio.codec_id = "RTCCodec_AudioMid_Outbound_42";
expected_audio.packets_sent = 2; expected_audio.packets_sent = 2;
@ -3200,7 +3200,7 @@ TEST_F(RTCStatsCollectorTest, CollectEchoReturnLossFromTrackAudioProcessor) {
rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport(); rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCMediaStreamTrackStats expected_local_audio_track_ssrc1( RTCMediaStreamTrackStats expected_local_audio_track_ssrc1(
IdForType<RTCMediaStreamTrackStats>(report), report->timestamp_us(), IdForType<RTCMediaStreamTrackStats>(report.get()), report->timestamp_us(),
RTCMediaStreamTrackKind::kAudio); RTCMediaStreamTrackKind::kAudio);
expected_local_audio_track_ssrc1.track_identifier = local_audio_track->id(); expected_local_audio_track_ssrc1.track_identifier = local_audio_track->id();
expected_local_audio_track_ssrc1.media_source_id = expected_local_audio_track_ssrc1.media_source_id =
@ -3493,7 +3493,8 @@ class FakeRTCStatsCollector : public RTCStatsCollector,
TEST(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) { TEST(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
auto pc = rtc::make_ref_counted<FakePeerConnectionForStats>(); auto pc = rtc::make_ref_counted<FakePeerConnectionForStats>();
rtc::scoped_refptr<FakeRTCStatsCollector> stats_collector( rtc::scoped_refptr<FakeRTCStatsCollector> stats_collector(
FakeRTCStatsCollector::Create(pc, 50 * rtc::kNumMicrosecsPerMillisec)); FakeRTCStatsCollector::Create(pc.get(),
50 * rtc::kNumMicrosecsPerMillisec));
stats_collector->VerifyThreadUsageAndResultsMerging(); stats_collector->VerifyThreadUsageAndResultsMerging();
} }

40
pc/rtc_stats_integrationtest.cc
View File

@ -174,8 +174,8 @@ class RTCStatsIntegrationTest : public ::testing::Test {
PeerConnectionInterface* pc) { PeerConnectionInterface* pc) {
rtc::scoped_refptr<RTCStatsObtainer> stats_obtainer = rtc::scoped_refptr<RTCStatsObtainer> stats_obtainer =
RTCStatsObtainer::Create(); RTCStatsObtainer::Create();
pc->GetStats(stats_obtainer); pc->GetStats(stats_obtainer.get());
EXPECT_TRUE_WAIT(stats_obtainer->report(), kGetStatsTimeoutMs); EXPECT_TRUE_WAIT(stats_obtainer->report() != nullptr, kGetStatsTimeoutMs);
return stats_obtainer->report(); return stats_obtainer->report();
} }
@ -186,7 +186,7 @@ class RTCStatsIntegrationTest : public ::testing::Test {
rtc::scoped_refptr<RTCStatsObtainer> stats_obtainer = rtc::scoped_refptr<RTCStatsObtainer> stats_obtainer =
RTCStatsObtainer::Create(); RTCStatsObtainer::Create();
pc->GetStats(selector, stats_obtainer); pc->GetStats(selector, stats_obtainer);
EXPECT_TRUE_WAIT(stats_obtainer->report(), kGetStatsTimeoutMs); EXPECT_TRUE_WAIT(stats_obtainer->report() != nullptr, kGetStatsTimeoutMs);
return stats_obtainer->report(); return stats_obtainer->report();
} }
@ -432,7 +432,7 @@ class RTCStatsReportVerifier {
} }
bool VerifyRTCCertificateStats(const RTCCertificateStats& certificate) { bool VerifyRTCCertificateStats(const RTCCertificateStats& certificate) {
RTCStatsVerifier verifier(report_, &certificate); RTCStatsVerifier verifier(report_.get(), &certificate);
verifier.TestMemberIsDefined(certificate.fingerprint); verifier.TestMemberIsDefined(certificate.fingerprint);
verifier.TestMemberIsDefined(certificate.fingerprint_algorithm); verifier.TestMemberIsDefined(certificate.fingerprint_algorithm);
verifier.TestMemberIsDefined(certificate.base64_certificate); verifier.TestMemberIsDefined(certificate.base64_certificate);
@ -442,7 +442,7 @@ class RTCStatsReportVerifier {
} }
bool VerifyRTCCodecStats(const RTCCodecStats& codec) { bool VerifyRTCCodecStats(const RTCCodecStats& codec) {
RTCStatsVerifier verifier(report_, &codec); RTCStatsVerifier verifier(report_.get(), &codec);
verifier.TestMemberIsIDReference(codec.transport_id, verifier.TestMemberIsIDReference(codec.transport_id,
RTCTransportStats::kType); RTCTransportStats::kType);
verifier.TestMemberIsDefined(codec.payload_type); verifier.TestMemberIsDefined(codec.payload_type);
@ -460,7 +460,7 @@ class RTCStatsReportVerifier {
} }
bool VerifyRTCDataChannelStats(const RTCDataChannelStats& data_channel) { bool VerifyRTCDataChannelStats(const RTCDataChannelStats& data_channel) {
RTCStatsVerifier verifier(report_, &data_channel); RTCStatsVerifier verifier(report_.get(), &data_channel);
verifier.TestMemberIsDefined(data_channel.label); verifier.TestMemberIsDefined(data_channel.label);
verifier.TestMemberIsDefined(data_channel.protocol); verifier.TestMemberIsDefined(data_channel.protocol);
verifier.TestMemberIsDefined(data_channel.data_channel_identifier); verifier.TestMemberIsDefined(data_channel.data_channel_identifier);
@ -475,7 +475,7 @@ class RTCStatsReportVerifier {
bool VerifyRTCIceCandidatePairStats( bool VerifyRTCIceCandidatePairStats(
const RTCIceCandidatePairStats& candidate_pair, const RTCIceCandidatePairStats& candidate_pair,
bool is_selected_pair) { bool is_selected_pair) {
RTCStatsVerifier verifier(report_, &candidate_pair); RTCStatsVerifier verifier(report_.get(), &candidate_pair);
verifier.TestMemberIsIDReference(candidate_pair.transport_id, verifier.TestMemberIsIDReference(candidate_pair.transport_id,
RTCTransportStats::kType); RTCTransportStats::kType);
verifier.TestMemberIsIDReference(candidate_pair.local_candidate_id, verifier.TestMemberIsIDReference(candidate_pair.local_candidate_id,
@ -526,7 +526,7 @@ class RTCStatsReportVerifier {
} }
bool VerifyRTCIceCandidateStats(const RTCIceCandidateStats& candidate) { bool VerifyRTCIceCandidateStats(const RTCIceCandidateStats& candidate) {
RTCStatsVerifier verifier(report_, &candidate); RTCStatsVerifier verifier(report_.get(), &candidate);
verifier.TestMemberIsIDReference(candidate.transport_id, verifier.TestMemberIsIDReference(candidate.transport_id,
RTCTransportStats::kType); RTCTransportStats::kType);
verifier.TestMemberIsDefined(candidate.is_remote); verifier.TestMemberIsDefined(candidate.is_remote);
@ -561,7 +561,7 @@ class RTCStatsReportVerifier {
} }
bool VerifyRTCMediaStreamStats(const RTCMediaStreamStats& media_stream) { bool VerifyRTCMediaStreamStats(const RTCMediaStreamStats& media_stream) {
RTCStatsVerifier verifier(report_, &media_stream); RTCStatsVerifier verifier(report_.get(), &media_stream);
verifier.TestMemberIsDefined(media_stream.stream_identifier); verifier.TestMemberIsDefined(media_stream.stream_identifier);
verifier.TestMemberIsIDReference(media_stream.track_ids, verifier.TestMemberIsIDReference(media_stream.track_ids,
RTCMediaStreamTrackStats::kType); RTCMediaStreamTrackStats::kType);
@ -570,7 +570,7 @@ class RTCStatsReportVerifier {
bool VerifyRTCMediaStreamTrackStats( bool VerifyRTCMediaStreamTrackStats(
const RTCMediaStreamTrackStats& media_stream_track) { const RTCMediaStreamTrackStats& media_stream_track) {
RTCStatsVerifier verifier(report_, &media_stream_track); RTCStatsVerifier verifier(report_.get(), &media_stream_track);
verifier.TestMemberIsDefined(media_stream_track.track_identifier); verifier.TestMemberIsDefined(media_stream_track.track_identifier);
verifier.TestMemberIsDefined(media_stream_track.remote_source); verifier.TestMemberIsDefined(media_stream_track.remote_source);
verifier.TestMemberIsDefined(media_stream_track.ended); verifier.TestMemberIsDefined(media_stream_track.ended);
@ -771,7 +771,7 @@ class RTCStatsReportVerifier {
bool VerifyRTCPeerConnectionStats( bool VerifyRTCPeerConnectionStats(
const RTCPeerConnectionStats& peer_connection) { const RTCPeerConnectionStats& peer_connection) {
RTCStatsVerifier verifier(report_, &peer_connection); RTCStatsVerifier verifier(report_.get(), &peer_connection);
verifier.TestMemberIsNonNegative<uint32_t>( verifier.TestMemberIsNonNegative<uint32_t>(
peer_connection.data_channels_opened); peer_connection.data_channels_opened);
verifier.TestMemberIsNonNegative<uint32_t>( verifier.TestMemberIsNonNegative<uint32_t>(
@ -808,7 +808,7 @@ class RTCStatsReportVerifier {
bool VerifyRTCInboundRTPStreamStats( bool VerifyRTCInboundRTPStreamStats(
const RTCInboundRTPStreamStats& inbound_stream) { const RTCInboundRTPStreamStats& inbound_stream) {
RTCStatsVerifier verifier(report_, &inbound_stream); RTCStatsVerifier verifier(report_.get(), &inbound_stream);
VerifyRTCReceivedRtpStreamStats(inbound_stream, verifier, VerifyRTCReceivedRtpStreamStats(inbound_stream, verifier,
inbound_stream.media_type.is_defined() && inbound_stream.media_type.is_defined() &&
*inbound_stream.media_type == "audio"); *inbound_stream.media_type == "audio");
@ -936,7 +936,7 @@ class RTCStatsReportVerifier {
bool VerifyRTCOutboundRTPStreamStats( bool VerifyRTCOutboundRTPStreamStats(
const RTCOutboundRTPStreamStats& outbound_stream) { const RTCOutboundRTPStreamStats& outbound_stream) {
RTCStatsVerifier verifier(report_, &outbound_stream); RTCStatsVerifier verifier(report_.get(), &outbound_stream);
VerifyRTCRTPStreamStats(outbound_stream, verifier); VerifyRTCRTPStreamStats(outbound_stream, verifier);
if (outbound_stream.media_type.is_defined() && if (outbound_stream.media_type.is_defined() &&
*outbound_stream.media_type == "video") { *outbound_stream.media_type == "video") {
@ -1048,7 +1048,7 @@ class RTCStatsReportVerifier {
bool VerifyRTCRemoteInboundRtpStreamStats( bool VerifyRTCRemoteInboundRtpStreamStats(
const RTCRemoteInboundRtpStreamStats& remote_inbound_stream) { const RTCRemoteInboundRtpStreamStats& remote_inbound_stream) {
RTCStatsVerifier verifier(report_, &remote_inbound_stream); RTCStatsVerifier verifier(report_.get(), &remote_inbound_stream);
VerifyRTCReceivedRtpStreamStats(remote_inbound_stream, verifier, false); VerifyRTCReceivedRtpStreamStats(remote_inbound_stream, verifier, false);
verifier.TestMemberIsDefined(remote_inbound_stream.fraction_lost); verifier.TestMemberIsDefined(remote_inbound_stream.fraction_lost);
verifier.TestMemberIsIDReference(remote_inbound_stream.local_id, verifier.TestMemberIsIDReference(remote_inbound_stream.local_id,
@ -1064,7 +1064,7 @@ class RTCStatsReportVerifier {
bool VerifyRTCRemoteOutboundRTPStreamStats( bool VerifyRTCRemoteOutboundRTPStreamStats(
const RTCRemoteOutboundRtpStreamStats& remote_outbound_stream) { const RTCRemoteOutboundRtpStreamStats& remote_outbound_stream) {
RTCStatsVerifier verifier(report_, &remote_outbound_stream); RTCStatsVerifier verifier(report_.get(), &remote_outbound_stream);
VerifyRTCRTPStreamStats(remote_outbound_stream, verifier); VerifyRTCRTPStreamStats(remote_outbound_stream, verifier);
VerifyRTCSentRTPStreamStats(remote_outbound_stream, verifier); VerifyRTCSentRTPStreamStats(remote_outbound_stream, verifier);
verifier.TestMemberIsIDReference(remote_outbound_stream.local_id, verifier.TestMemberIsIDReference(remote_outbound_stream.local_id,
@ -1088,7 +1088,7 @@ class RTCStatsReportVerifier {
} }
bool VerifyRTCAudioSourceStats(const RTCAudioSourceStats& audio_source) { bool VerifyRTCAudioSourceStats(const RTCAudioSourceStats& audio_source) {
RTCStatsVerifier verifier(report_, &audio_source); RTCStatsVerifier verifier(report_.get(), &audio_source);
VerifyRTCMediaSourceStats(audio_source, &verifier); VerifyRTCMediaSourceStats(audio_source, &verifier);
// Audio level, unlike audio energy, only gets updated at a certain // Audio level, unlike audio energy, only gets updated at a certain
// frequency, so we don't require that one to be positive to avoid a race // frequency, so we don't require that one to be positive to avoid a race
@ -1106,7 +1106,7 @@ class RTCStatsReportVerifier {
} }
bool VerifyRTCVideoSourceStats(const RTCVideoSourceStats& video_source) { bool VerifyRTCVideoSourceStats(const RTCVideoSourceStats& video_source) {
RTCStatsVerifier verifier(report_, &video_source); RTCStatsVerifier verifier(report_.get(), &video_source);
VerifyRTCMediaSourceStats(video_source, &verifier); VerifyRTCMediaSourceStats(video_source, &verifier);
// TODO(hbos): This integration test uses fakes that doesn't support // TODO(hbos): This integration test uses fakes that doesn't support
// VideoTrackSourceInterface::Stats. When this is fixed we should // VideoTrackSourceInterface::Stats. When this is fixed we should
@ -1120,7 +1120,7 @@ class RTCStatsReportVerifier {
} }
bool VerifyRTCTransportStats(const RTCTransportStats& transport) { bool VerifyRTCTransportStats(const RTCTransportStats& transport) {
RTCStatsVerifier verifier(report_, &transport); RTCStatsVerifier verifier(report_.get(), &transport);
verifier.TestMemberIsNonNegative<uint64_t>(transport.bytes_sent); verifier.TestMemberIsNonNegative<uint64_t>(transport.bytes_sent);
verifier.TestMemberIsNonNegative<uint64_t>(transport.packets_sent); verifier.TestMemberIsNonNegative<uint64_t>(transport.packets_sent);
verifier.TestMemberIsNonNegative<uint64_t>(transport.bytes_received); verifier.TestMemberIsNonNegative<uint64_t>(transport.bytes_received);
@ -1240,7 +1240,7 @@ TEST_F(RTCStatsIntegrationTest,
rtc::scoped_refptr<RTCStatsObtainer> stats_obtainer = rtc::scoped_refptr<RTCStatsObtainer> stats_obtainer =
RTCStatsObtainer::Create(); RTCStatsObtainer::Create();
caller_->pc()->GetStats(stats_obtainer); caller_->pc()->GetStats(stats_obtainer.get());
// This will destroy the peer connection. // This will destroy the peer connection.
caller_ = nullptr; caller_ = nullptr;
// Any pending stats requests should have completed in the act of destroying // Any pending stats requests should have completed in the act of destroying
@ -1257,7 +1257,7 @@ TEST_F(RTCStatsIntegrationTest, GetsStatsWhileClosingPeerConnection) {
rtc::scoped_refptr<RTCStatsObtainer> stats_obtainer = rtc::scoped_refptr<RTCStatsObtainer> stats_obtainer =
RTCStatsObtainer::Create(); RTCStatsObtainer::Create();
caller_->pc()->GetStats(stats_obtainer); caller_->pc()->GetStats(stats_obtainer.get());
caller_->pc()->Close(); caller_->pc()->Close();
ASSERT_TRUE(stats_obtainer->report()); ASSERT_TRUE(stats_obtainer->report());

3
pc/rtp_sender.cc
View File

@ -651,7 +651,8 @@ void VideoRtpSender::SetSend() {
break; break;
} }
bool success = worker_thread_->Invoke<bool>(RTC_FROM_HERE, [&] { bool success = worker_thread_->Invoke<bool>(RTC_FROM_HERE, [&] {
return video_media_channel()->SetVideoSend(ssrc_, &options, video_track()); return video_media_channel()->SetVideoSend(ssrc_, &options,
video_track().get());
}); });
RTC_DCHECK(success); RTC_DCHECK(success);
} }

30
pc/rtp_sender_receiver_unittest.cc
View File

@ -210,7 +210,7 @@ class RtpSenderReceiverTest
FakeVideoTrackSource::Create(is_screencast)); FakeVideoTrackSource::Create(is_screencast));
video_track_ = video_track_ =
VideoTrack::Create(kVideoTrackId, source, rtc::Thread::Current()); VideoTrack::Create(kVideoTrackId, source, rtc::Thread::Current());
EXPECT_TRUE(local_stream_->AddTrack(video_track_)); EXPECT_TRUE(local_stream_->AddTrack(video_track_.get()));
} }
void CreateAudioRtpSender() { CreateAudioRtpSender(nullptr); } void CreateAudioRtpSender() { CreateAudioRtpSender(nullptr); }
@ -218,13 +218,13 @@ class RtpSenderReceiverTest
void CreateAudioRtpSender( void CreateAudioRtpSender(
const rtc::scoped_refptr<LocalAudioSource>& source) { const rtc::scoped_refptr<LocalAudioSource>& source) {
audio_track_ = AudioTrack::Create(kAudioTrackId, source); audio_track_ = AudioTrack::Create(kAudioTrackId, source);
EXPECT_TRUE(local_stream_->AddTrack(audio_track_)); EXPECT_TRUE(local_stream_->AddTrack(audio_track_.get()));
std::unique_ptr<MockSetStreamsObserver> set_streams_observer = std::unique_ptr<MockSetStreamsObserver> set_streams_observer =
std::make_unique<MockSetStreamsObserver>(); std::make_unique<MockSetStreamsObserver>();
audio_rtp_sender_ = audio_rtp_sender_ =
AudioRtpSender::Create(worker_thread_, audio_track_->id(), nullptr, AudioRtpSender::Create(worker_thread_, audio_track_->id(), nullptr,
set_streams_observer.get()); set_streams_observer.get());
ASSERT_TRUE(audio_rtp_sender_->SetTrack(audio_track_)); ASSERT_TRUE(audio_rtp_sender_->SetTrack(audio_track_.get()));
EXPECT_CALL(*set_streams_observer, OnSetStreams()); EXPECT_CALL(*set_streams_observer, OnSetStreams());
audio_rtp_sender_->SetStreams({local_stream_->id()}); audio_rtp_sender_->SetStreams({local_stream_->id()});
audio_rtp_sender_->SetMediaChannel(voice_media_channel_); audio_rtp_sender_->SetMediaChannel(voice_media_channel_);
@ -288,7 +288,7 @@ class RtpSenderReceiverTest
std::make_unique<MockSetStreamsObserver>(); std::make_unique<MockSetStreamsObserver>();
video_rtp_sender_ = VideoRtpSender::Create( video_rtp_sender_ = VideoRtpSender::Create(
worker_thread_, video_track_->id(), set_streams_observer.get()); worker_thread_, video_track_->id(), set_streams_observer.get());
ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_)); ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_.get()));
EXPECT_CALL(*set_streams_observer, OnSetStreams()); EXPECT_CALL(*set_streams_observer, OnSetStreams());
video_rtp_sender_->SetStreams({local_stream_->id()}); video_rtp_sender_->SetStreams({local_stream_->id()});
video_rtp_sender_->SetMediaChannel(video_media_channel_); video_rtp_sender_->SetMediaChannel(video_media_channel_);
@ -733,7 +733,7 @@ TEST_F(RtpSenderReceiverTest, AudioSenderWithoutTrackAndSsrc) {
AudioTrack::Create(kAudioTrackId, nullptr); AudioTrack::Create(kAudioTrackId, nullptr);
// Track but no SSRC. // Track but no SSRC.
EXPECT_TRUE(audio_rtp_sender_->SetTrack(track)); EXPECT_TRUE(audio_rtp_sender_->SetTrack(track.get()));
VerifyVoiceChannelNoInput(); VerifyVoiceChannelNoInput();
// SSRC but no track. // SSRC but no track.
@ -748,7 +748,7 @@ TEST_F(RtpSenderReceiverTest, VideoSenderWithoutTrackAndSsrc) {
CreateVideoRtpSenderWithNoTrack(); CreateVideoRtpSenderWithNoTrack();
// Track but no SSRC. // Track but no SSRC.
EXPECT_TRUE(video_rtp_sender_->SetTrack(video_track_)); EXPECT_TRUE(video_rtp_sender_->SetTrack(video_track_.get()));
VerifyVideoChannelNoInput(); VerifyVideoChannelNoInput();
// SSRC but no track. // SSRC but no track.
@ -764,7 +764,7 @@ TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupSsrcThenTrack) {
rtc::scoped_refptr<AudioTrackInterface> track = rtc::scoped_refptr<AudioTrackInterface> track =
AudioTrack::Create(kAudioTrackId, nullptr); AudioTrack::Create(kAudioTrackId, nullptr);
audio_rtp_sender_->SetSsrc(kAudioSsrc); audio_rtp_sender_->SetSsrc(kAudioSsrc);
audio_rtp_sender_->SetTrack(track); audio_rtp_sender_->SetTrack(track.get());
VerifyVoiceChannelInput(); VerifyVoiceChannelInput();
DestroyAudioRtpSender(); DestroyAudioRtpSender();
@ -776,7 +776,7 @@ TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupTrackThenSsrc) {
CreateAudioRtpSenderWithNoTrack(); CreateAudioRtpSenderWithNoTrack();
rtc::scoped_refptr<AudioTrackInterface> track = rtc::scoped_refptr<AudioTrackInterface> track =
AudioTrack::Create(kAudioTrackId, nullptr); AudioTrack::Create(kAudioTrackId, nullptr);
audio_rtp_sender_->SetTrack(track); audio_rtp_sender_->SetTrack(track.get());
audio_rtp_sender_->SetSsrc(kAudioSsrc); audio_rtp_sender_->SetSsrc(kAudioSsrc);
VerifyVoiceChannelInput(); VerifyVoiceChannelInput();
@ -789,7 +789,7 @@ TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupSsrcThenTrack) {
AddVideoTrack(); AddVideoTrack();
CreateVideoRtpSenderWithNoTrack(); CreateVideoRtpSenderWithNoTrack();
video_rtp_sender_->SetSsrc(kVideoSsrc); video_rtp_sender_->SetSsrc(kVideoSsrc);
video_rtp_sender_->SetTrack(video_track_); video_rtp_sender_->SetTrack(video_track_.get());
VerifyVideoChannelInput(); VerifyVideoChannelInput();
DestroyVideoRtpSender(); DestroyVideoRtpSender();
@ -800,7 +800,7 @@ TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupSsrcThenTrack) {
TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupTrackThenSsrc) { TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupTrackThenSsrc) {
AddVideoTrack(); AddVideoTrack();
CreateVideoRtpSenderWithNoTrack(); CreateVideoRtpSenderWithNoTrack();
video_rtp_sender_->SetTrack(video_track_); video_rtp_sender_->SetTrack(video_track_.get());
video_rtp_sender_->SetSsrc(kVideoSsrc); video_rtp_sender_->SetSsrc(kVideoSsrc);
VerifyVideoChannelInput(); VerifyVideoChannelInput();
@ -897,13 +897,13 @@ TEST_F(RtpSenderReceiverTest, AudioSenderCanSetParametersBeforeNegotiation) {
TEST_F(RtpSenderReceiverTest, AudioSenderInitParametersMovedAfterNegotiation) { TEST_F(RtpSenderReceiverTest, AudioSenderInitParametersMovedAfterNegotiation) {
audio_track_ = AudioTrack::Create(kAudioTrackId, nullptr); audio_track_ = AudioTrack::Create(kAudioTrackId, nullptr);
EXPECT_TRUE(local_stream_->AddTrack(audio_track_)); EXPECT_TRUE(local_stream_->AddTrack(audio_track_.get()));
std::unique_ptr<MockSetStreamsObserver> set_streams_observer = std::unique_ptr<MockSetStreamsObserver> set_streams_observer =
std::make_unique<MockSetStreamsObserver>(); std::make_unique<MockSetStreamsObserver>();
audio_rtp_sender_ = AudioRtpSender::Create( audio_rtp_sender_ = AudioRtpSender::Create(
worker_thread_, audio_track_->id(), nullptr, set_streams_observer.get()); worker_thread_, audio_track_->id(), nullptr, set_streams_observer.get());
ASSERT_TRUE(audio_rtp_sender_->SetTrack(audio_track_)); ASSERT_TRUE(audio_rtp_sender_->SetTrack(audio_track_.get()));
EXPECT_CALL(*set_streams_observer, OnSetStreams()); EXPECT_CALL(*set_streams_observer, OnSetStreams());
audio_rtp_sender_->SetStreams({local_stream_->id()}); audio_rtp_sender_->SetStreams({local_stream_->id()});
@ -1094,7 +1094,7 @@ TEST_F(RtpSenderReceiverTest, VideoSenderInitParametersMovedAfterNegotiation) {
std::make_unique<MockSetStreamsObserver>(); std::make_unique<MockSetStreamsObserver>();
video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, video_track_->id(), video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, video_track_->id(),
set_streams_observer.get()); set_streams_observer.get());
ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_)); ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_.get()));
EXPECT_CALL(*set_streams_observer, OnSetStreams()); EXPECT_CALL(*set_streams_observer, OnSetStreams());
video_rtp_sender_->SetStreams({local_stream_->id()}); video_rtp_sender_->SetStreams({local_stream_->id()});
@ -1135,7 +1135,7 @@ TEST_F(RtpSenderReceiverTest,
std::make_unique<MockSetStreamsObserver>(); std::make_unique<MockSetStreamsObserver>();
video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, video_track_->id(), video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, video_track_->id(),
set_streams_observer.get()); set_streams_observer.get());
ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_)); ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_.get()));
EXPECT_CALL(*set_streams_observer, OnSetStreams()); EXPECT_CALL(*set_streams_observer, OnSetStreams());
video_rtp_sender_->SetStreams({local_stream_->id()}); video_rtp_sender_->SetStreams({local_stream_->id()});
@ -1524,7 +1524,7 @@ TEST_F(RtpSenderReceiverTest,
video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed); video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed);
video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, video_track_->id(), video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, video_track_->id(),
set_streams_observer.get()); set_streams_observer.get());
ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_)); ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_.get()));
EXPECT_CALL(*set_streams_observer, OnSetStreams()); EXPECT_CALL(*set_streams_observer, OnSetStreams());
video_rtp_sender_->SetStreams({local_stream_->id()}); video_rtp_sender_->SetStreams({local_stream_->id()});
video_rtp_sender_->SetMediaChannel(video_media_channel_); video_rtp_sender_->SetMediaChannel(video_media_channel_);

16
pc/rtp_transmission_manager.cc
View File

@ -177,7 +177,7 @@ RtpTransmissionManager::AddTrackUnifiedPlan(
transceiver->internal()->set_direction( transceiver->internal()->set_direction(
RtpTransceiverDirection::kSendOnly); RtpTransceiverDirection::kSendOnly);
} }
transceiver->sender()->SetTrack(track); transceiver->sender()->SetTrack(track.get());
transceiver->internal()->sender_internal()->set_stream_ids(stream_ids); transceiver->internal()->sender_internal()->set_stream_ids(stream_ids);
transceiver->internal()->set_reused_for_addtrack(true); transceiver->internal()->set_reused_for_addtrack(true);
} else { } else {
@ -227,7 +227,7 @@ RtpTransmissionManager::CreateSender(
signaling_thread(), VideoRtpSender::Create(worker_thread(), id, this)); signaling_thread(), VideoRtpSender::Create(worker_thread(), id, this));
NoteUsageEvent(UsageEvent::VIDEO_ADDED); NoteUsageEvent(UsageEvent::VIDEO_ADDED);
} }
bool set_track_succeeded = sender->SetTrack(track); bool set_track_succeeded = sender->SetTrack(track.get());
RTC_DCHECK(set_track_succeeded); RTC_DCHECK(set_track_succeeded);
sender->internal()->set_stream_ids(stream_ids); sender->internal()->set_stream_ids(stream_ids);
sender->internal()->set_init_send_encodings(send_encodings); sender->internal()->set_init_send_encodings(send_encodings);
@ -409,7 +409,7 @@ void RtpTransmissionManager::RemoveAudioTrack(AudioTrackInterface* track,
<< " doesn't exist."; << " doesn't exist.";
return; return;
} }
GetAudioTransceiver()->internal()->RemoveSender(sender); GetAudioTransceiver()->internal()->RemoveSender(sender.get());
} }
void RtpTransmissionManager::AddVideoTrack(VideoTrackInterface* track, void RtpTransmissionManager::AddVideoTrack(VideoTrackInterface* track,
@ -448,7 +448,7 @@ void RtpTransmissionManager::RemoveVideoTrack(VideoTrackInterface* track,
<< " doesn't exist."; << " doesn't exist.";
return; return;
} }
GetVideoTransceiver()->internal()->RemoveSender(sender); GetVideoTransceiver()->internal()->RemoveSender(sender.get());
} }
void RtpTransmissionManager::CreateAudioReceiver( void RtpTransmissionManager::CreateAudioReceiver(
@ -511,9 +511,9 @@ RtpTransmissionManager::RemoveAndStopReceiver(
return nullptr; return nullptr;
} }
if (receiver->media_type() == cricket::MEDIA_TYPE_AUDIO) { if (receiver->media_type() == cricket::MEDIA_TYPE_AUDIO) {
GetAudioTransceiver()->internal()->RemoveReceiver(receiver); GetAudioTransceiver()->internal()->RemoveReceiver(receiver.get());
} else { } else {
GetVideoTransceiver()->internal()->RemoveReceiver(receiver); GetVideoTransceiver()->internal()->RemoveReceiver(receiver.get());
} }
return receiver; return receiver;
} }
@ -553,7 +553,7 @@ void RtpTransmissionManager::OnRemoteSenderRemoved(
rtc::scoped_refptr<AudioTrackInterface> audio_track = rtc::scoped_refptr<AudioTrackInterface> audio_track =
stream->FindAudioTrack(sender_info.sender_id); stream->FindAudioTrack(sender_info.sender_id);
if (audio_track) { if (audio_track) {
stream->RemoveTrack(audio_track); stream->RemoveTrack(audio_track.get());
} }
} else if (media_type == cricket::MEDIA_TYPE_VIDEO) { } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
// Stopping or destroying a VideoRtpReceiver will end the // Stopping or destroying a VideoRtpReceiver will end the
@ -564,7 +564,7 @@ void RtpTransmissionManager::OnRemoteSenderRemoved(
if (video_track) { if (video_track) {
// There's no guarantee the track is still available, e.g. the track may // There's no guarantee the track is still available, e.g. the track may
// have been removed from the stream by an application. // have been removed from the stream by an application.
stream->RemoveTrack(video_track); stream->RemoveTrack(video_track.get());
} }
} else { } else {
RTC_DCHECK_NOTREACHED() << "Invalid media type"; RTC_DCHECK_NOTREACHED() << "Invalid media type";

2
pc/scenario_tests/goog_cc_test.cc
View File

@ -75,7 +75,7 @@ TEST(GoogCcPeerScenarioTest, MAYBE_NoBweChangeFromVideoUnmute) {
auto get_bwe = [&] { auto get_bwe = [&] {
auto callback = auto callback =
rtc::make_ref_counted<webrtc::MockRTCStatsCollectorCallback>(); rtc::make_ref_counted<webrtc::MockRTCStatsCollectorCallback>();
caller->pc()->GetStats(callback); caller->pc()->GetStats(callback.get());
s.net()->time_controller()->Wait([&] { return callback->called(); }); s.net()->time_controller()->Wait([&] { return callback->called(); });
auto stats = auto stats =
callback->report()->GetStatsOfType<RTCIceCandidatePairStats>()[0]; callback->report()->GetStatsOfType<RTCIceCandidatePairStats>()[0];

40
pc/sdp_offer_answer.cc
View File

@ -1100,10 +1100,10 @@ class SdpOfferAnswerHandler::SetSessionDescriptionObserverAdapter
return; return;
if (error.ok()) { if (error.ok()) {
handler_->pc_->message_handler()->PostSetSessionDescriptionSuccess( handler_->pc_->message_handler()->PostSetSessionDescriptionSuccess(
inner_observer_); inner_observer_.get());
} else { } else {
handler_->pc_->message_handler()->PostSetSessionDescriptionFailure( handler_->pc_->message_handler()->PostSetSessionDescriptionFailure(
inner_observer_, std::move(error)); inner_observer_.get(), std::move(error));
} }
} }
@ -2029,7 +2029,7 @@ void SdpOfferAnswerHandler::ApplyRemoteDescriptionUpdateTransceiverState(
// Once all processing has finished, fire off callbacks. // Once all processing has finished, fire off callbacks.
auto observer = pc_->Observer(); auto observer = pc_->Observer();
for (const auto& transceiver : now_receiving_transceivers) { for (const auto& transceiver : now_receiving_transceivers) {
pc_->stats()->AddTrack(transceiver->receiver()->track()); pc_->stats()->AddTrack(transceiver->receiver()->track().get());
observer->OnTrack(transceiver); observer->OnTrack(transceiver);
observer->OnAddTrack(transceiver->receiver(), observer->OnAddTrack(transceiver->receiver(),
transceiver->receiver()->streams()); transceiver->receiver()->streams());
@ -2076,7 +2076,7 @@ void SdpOfferAnswerHandler::PlanBUpdateSendersAndReceivers(
RtpTransceiverDirectionHasSend(audio_desc->direction()); RtpTransceiverDirectionHasSend(audio_desc->direction());
UpdateRemoteSendersList(GetActiveStreams(audio_desc), UpdateRemoteSendersList(GetActiveStreams(audio_desc),
default_audio_track_needed, audio_desc->type(), default_audio_track_needed, audio_desc->type(),
new_streams); new_streams.get());
} }
} }
@ -2091,7 +2091,7 @@ void SdpOfferAnswerHandler::PlanBUpdateSendersAndReceivers(
RtpTransceiverDirectionHasSend(video_desc->direction()); RtpTransceiverDirectionHasSend(video_desc->direction());
UpdateRemoteSendersList(GetActiveStreams(video_desc), UpdateRemoteSendersList(GetActiveStreams(video_desc),
default_video_track_needed, video_desc->type(), default_video_track_needed, video_desc->type(),
new_streams); new_streams.get());
} }
} }
@ -2229,7 +2229,8 @@ void SdpOfferAnswerHandler::DoCreateOffer(
std::string error = "CreateOffer called when PeerConnection is closed."; std::string error = "CreateOffer called when PeerConnection is closed.";
RTC_LOG(LS_ERROR) << error; RTC_LOG(LS_ERROR) << error;
pc_->message_handler()->PostCreateSessionDescriptionFailure( pc_->message_handler()->PostCreateSessionDescriptionFailure(
observer, RTCError(RTCErrorType::INVALID_STATE, std::move(error))); observer.get(),
RTCError(RTCErrorType::INVALID_STATE, std::move(error)));
return; return;
} }
@ -2239,7 +2240,7 @@ void SdpOfferAnswerHandler::DoCreateOffer(
std::string error_message = GetSessionErrorMsg(); std::string error_message = GetSessionErrorMsg();
RTC_LOG(LS_ERROR) << "CreateOffer: " << error_message; RTC_LOG(LS_ERROR) << "CreateOffer: " << error_message;
pc_->message_handler()->PostCreateSessionDescriptionFailure( pc_->message_handler()->PostCreateSessionDescriptionFailure(
observer, observer.get(),
RTCError(RTCErrorType::INTERNAL_ERROR, std::move(error_message))); RTCError(RTCErrorType::INTERNAL_ERROR, std::move(error_message)));
return; return;
} }
@ -2248,7 +2249,8 @@ void SdpOfferAnswerHandler::DoCreateOffer(
std::string error = "CreateOffer called with invalid options."; std::string error = "CreateOffer called with invalid options.";
RTC_LOG(LS_ERROR) << error; RTC_LOG(LS_ERROR) << error;
pc_->message_handler()->PostCreateSessionDescriptionFailure( pc_->message_handler()->PostCreateSessionDescriptionFailure(
observer, RTCError(RTCErrorType::INVALID_PARAMETER, std::move(error))); observer.get(),
RTCError(RTCErrorType::INVALID_PARAMETER, std::move(error)));
return; return;
} }
@ -2258,14 +2260,15 @@ void SdpOfferAnswerHandler::DoCreateOffer(
RTCError error = HandleLegacyOfferOptions(options); RTCError error = HandleLegacyOfferOptions(options);
if (!error.ok()) { if (!error.ok()) {
pc_->message_handler()->PostCreateSessionDescriptionFailure( pc_->message_handler()->PostCreateSessionDescriptionFailure(
observer, std::move(error)); observer.get(), std::move(error));
return; return;
} }
} }
cricket::MediaSessionOptions session_options; cricket::MediaSessionOptions session_options;
GetOptionsForOffer(options, &session_options); GetOptionsForOffer(options, &session_options);
webrtc_session_desc_factory_->CreateOffer(observer, options, session_options); webrtc_session_desc_factory_->CreateOffer(observer.get(), options,
session_options);
} }
void SdpOfferAnswerHandler::CreateAnswer( void SdpOfferAnswerHandler::CreateAnswer(
@ -2313,7 +2316,7 @@ void SdpOfferAnswerHandler::DoCreateAnswer(
std::string error_message = GetSessionErrorMsg(); std::string error_message = GetSessionErrorMsg();
RTC_LOG(LS_ERROR) << "CreateAnswer: " << error_message; RTC_LOG(LS_ERROR) << "CreateAnswer: " << error_message;
pc_->message_handler()->PostCreateSessionDescriptionFailure( pc_->message_handler()->PostCreateSessionDescriptionFailure(
observer, observer.get(),
RTCError(RTCErrorType::INTERNAL_ERROR, std::move(error_message))); RTCError(RTCErrorType::INTERNAL_ERROR, std::move(error_message)));
return; return;
} }
@ -2325,7 +2328,8 @@ void SdpOfferAnswerHandler::DoCreateAnswer(
"have-remote-offer or have-local-pranswer."; "have-remote-offer or have-local-pranswer.";
RTC_LOG(LS_ERROR) << error; RTC_LOG(LS_ERROR) << error;
pc_->message_handler()->PostCreateSessionDescriptionFailure( pc_->message_handler()->PostCreateSessionDescriptionFailure(
observer, RTCError(RTCErrorType::INVALID_STATE, std::move(error))); observer.get(),
RTCError(RTCErrorType::INVALID_STATE, std::move(error)));
return; return;
} }
@ -2349,7 +2353,7 @@ void SdpOfferAnswerHandler::DoCreateAnswer(
cricket::MediaSessionOptions session_options; cricket::MediaSessionOptions session_options;
GetOptionsForAnswer(options, &session_options); GetOptionsForAnswer(options, &session_options);
webrtc_session_desc_factory_->CreateAnswer(observer, session_options); webrtc_session_desc_factory_->CreateAnswer(observer.get(), session_options);
} }
void SdpOfferAnswerHandler::DoSetRemoteDescription( void SdpOfferAnswerHandler::DoSetRemoteDescription(
@ -2775,7 +2779,7 @@ bool SdpOfferAnswerHandler::AddStream(MediaStreamInterface* local_stream) {
if (pc_->IsClosed()) { if (pc_->IsClosed()) {
return false; return false;
} }
if (!CanAddLocalMediaStream(local_streams_, local_stream)) { if (!CanAddLocalMediaStream(local_streams_.get(), local_stream)) {
return false; return false;
} }
@ -4245,7 +4249,7 @@ void SdpOfferAnswerHandler::RemoveRemoteStreamsIfEmpty(
for (const auto& remote_stream : remote_streams) { for (const auto& remote_stream : remote_streams) {
if (remote_stream->GetAudioTracks().empty() && if (remote_stream->GetAudioTracks().empty() &&
remote_stream->GetVideoTracks().empty()) { remote_stream->GetVideoTracks().empty()) {
remote_streams_->RemoveStream(remote_stream); remote_streams_->RemoveStream(remote_stream.get());
removed_streams->push_back(remote_stream); removed_streams->push_back(remote_stream);
} }
} }
@ -4373,7 +4377,7 @@ void SdpOfferAnswerHandler::UpdateRemoteSendersList(
rtp_manager()->FindSenderInfo(*current_senders, stream_id, sender_id); rtp_manager()->FindSenderInfo(*current_senders, stream_id, sender_id);
if (!sender_info) { if (!sender_info) {
current_senders->push_back(RtpSenderInfo(stream_id, sender_id, ssrc)); current_senders->push_back(RtpSenderInfo(stream_id, sender_id, ssrc));
rtp_manager()->OnRemoteSenderAdded(current_senders->back(), stream, rtp_manager()->OnRemoteSenderAdded(current_senders->back(), stream.get(),
media_type); media_type);
} }
} }
@ -4398,7 +4402,7 @@ void SdpOfferAnswerHandler::UpdateRemoteSendersList(
current_senders->push_back( current_senders->push_back(
RtpSenderInfo(kDefaultStreamId, default_sender_id, /*ssrc=*/0)); RtpSenderInfo(kDefaultStreamId, default_sender_id, /*ssrc=*/0));
rtp_manager()->OnRemoteSenderAdded(current_senders->back(), rtp_manager()->OnRemoteSenderAdded(current_senders->back(),
default_stream, media_type); default_stream.get(), media_type);
} }
} }
} }
@ -4633,7 +4637,7 @@ void SdpOfferAnswerHandler::UpdateEndedRemoteMediaStreams() {
} }
for (auto& stream : streams_to_remove) { for (auto& stream : streams_to_remove) {
remote_streams_->RemoveStream(stream); remote_streams_->RemoveStream(stream.get());
pc_->Observer()->OnRemoveStream(std::move(stream)); pc_->Observer()->OnRemoveStream(std::move(stream));
} }
} }

2
pc/sdp_offer_answer_unittest.cc
View File

@ -85,7 +85,7 @@ class SdpOfferAnswerTest : public ::testing::Test {
auto result = pc_factory_->CreatePeerConnectionOrError( auto result = pc_factory_->CreatePeerConnectionOrError(
config, PeerConnectionDependencies(observer.get())); config, PeerConnectionDependencies(observer.get()));
EXPECT_TRUE(result.ok()); EXPECT_TRUE(result.ok());
observer->SetPeerConnectionInterface(result.value()); observer->SetPeerConnectionInterface(result.value().get());
return std::make_unique<PeerConnectionWrapper>( return std::make_unique<PeerConnectionWrapper>(
pc_factory_, result.MoveValue(), std::move(observer)); pc_factory_, result.MoveValue(), std::move(observer));
} }

149
pc/stats_collector_unittest.cc
View File

@ -666,7 +666,7 @@ class StatsCollectorTest : public ::testing::Test {
const std::string kTransportName = "transport"; const std::string kTransportName = "transport";
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
pc->AddVoiceChannel("audio", kTransportName); pc->AddVoiceChannel("audio", kTransportName);
@ -779,10 +779,10 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
if (GetParam()) { if (GetParam()) {
if (!stream_) if (!stream_)
stream_ = MediaStream::Create("streamid"); stream_ = MediaStream::Create("streamid");
stream_->AddTrack(track_); stream_->AddTrack(track_.get());
stats->AddStream(stream_); stats->AddStream(stream_.get());
} else { } else {
stats->AddTrack(track_); stats->AddTrack(track_.get());
} }
pc->AddSender(CreateMockSender(track_, kSsrcOfTrack)); pc->AddSender(CreateMockSender(track_, kSsrcOfTrack));
} }
@ -794,10 +794,10 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
rtc::Thread::Current()); rtc::Thread::Current());
if (GetParam()) { if (GetParam()) {
stream_ = MediaStream::Create("streamid"); stream_ = MediaStream::Create("streamid");
stream_->AddTrack(track_); stream_->AddTrack(track_.get());
stats->AddStream(stream_); stats->AddStream(stream_.get());
} else { } else {
stats->AddTrack(track_); stats->AddTrack(track_.get());
} }
pc->AddReceiver(CreateMockReceiver(track_, kSsrcOfTrack)); pc->AddReceiver(CreateMockReceiver(track_, kSsrcOfTrack));
} }
@ -813,10 +813,10 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
if (GetParam()) { if (GetParam()) {
if (!stream_) if (!stream_)
stream_ = MediaStream::Create("streamid"); stream_ = MediaStream::Create("streamid");
stream_->AddTrack(audio_track_); stream_->AddTrack(audio_track_.get());
stats->AddStream(stream_); stats->AddStream(stream_.get());
} else { } else {
stats->AddTrack(audio_track_); stats->AddTrack(audio_track_.get());
} }
return pc->AddSender(CreateMockSender(audio_track_, kSsrcOfTrack)); return pc->AddSender(CreateMockSender(audio_track_, kSsrcOfTrack));
} }
@ -826,12 +826,12 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
StatsCollectorForTest* stats) { StatsCollectorForTest* stats) {
audio_track_ = rtc::make_ref_counted<FakeAudioTrack>(kRemoteTrackId); audio_track_ = rtc::make_ref_counted<FakeAudioTrack>(kRemoteTrackId);
if (GetParam()) { if (GetParam()) {
if (stream_ == NULL) if (stream_ == nullptr)
stream_ = MediaStream::Create("streamid"); stream_ = MediaStream::Create("streamid");
stream_->AddTrack(audio_track_); stream_->AddTrack(audio_track_.get());
stats->AddStream(stream_); stats->AddStream(stream_.get());
} else { } else {
stats->AddTrack(audio_track_); stats->AddTrack(audio_track_.get());
} }
pc->AddReceiver(CreateMockReceiver(audio_track_, kSsrcOfTrack)); pc->AddReceiver(CreateMockReceiver(audio_track_, kSsrcOfTrack));
} }
@ -843,7 +843,7 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
TEST_F(StatsCollectorTest, FilterOutNegativeDataChannelId) { TEST_F(StatsCollectorTest, FilterOutNegativeDataChannelId) {
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
pc->AddSctpDataChannel("hacks"); pc->AddSctpDataChannel("hacks");
@ -867,7 +867,7 @@ TEST_F(StatsCollectorTest, ExtractDataInfo) {
DataChannelInterface::DataState::kConnecting); DataChannelInterface::DataState::kConnecting);
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
InternalDataChannelInit init; InternalDataChannelInit init;
init.id = kDataChannelId; init.id = kDataChannelId;
@ -906,7 +906,7 @@ TEST_P(StatsCollectorTrackTest, BytesCounterHandles64Bits) {
constexpr int64_t kBytesSent = 12345678901234LL; constexpr int64_t kBytesSent = 12345678901234LL;
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
VideoSenderInfo video_sender_info; VideoSenderInfo video_sender_info;
video_sender_info.add_ssrc(1234); video_sender_info.add_ssrc(1234);
@ -917,7 +917,7 @@ TEST_P(StatsCollectorTrackTest, BytesCounterHandles64Bits) {
pc->AddVideoChannel("video", "transport", video_info); pc->AddVideoChannel("video", "transport", video_info);
AddOutgoingVideoTrack(pc, stats.get()); AddOutgoingVideoTrack(pc.get(), stats.get());
stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
StatsReports reports; StatsReports reports;
@ -938,7 +938,7 @@ TEST_P(StatsCollectorTrackTest, AudioBandwidthEstimationInfoIsReported) {
constexpr int kPacerDelay = 123; constexpr int kPacerDelay = 123;
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
VoiceSenderInfo voice_sender_info; VoiceSenderInfo voice_sender_info;
voice_sender_info.add_ssrc(1234); voice_sender_info.add_ssrc(1234);
@ -950,7 +950,7 @@ TEST_P(StatsCollectorTrackTest, AudioBandwidthEstimationInfoIsReported) {
auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport"); auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
voice_media_channel->SetStats(voice_info); voice_media_channel->SetStats(voice_info);
AddOutgoingAudioTrack(pc, stats.get()); AddOutgoingAudioTrack(pc.get(), stats.get());
Call::Stats call_stats; Call::Stats call_stats;
call_stats.send_bandwidth_bps = kSendBandwidth; call_stats.send_bandwidth_bps = kSendBandwidth;
@ -987,7 +987,7 @@ TEST_P(StatsCollectorTrackTest, VideoBandwidthEstimationInfoIsReported) {
constexpr int kPacerDelay = 123; constexpr int kPacerDelay = 123;
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
VideoSenderInfo video_sender_info; VideoSenderInfo video_sender_info;
video_sender_info.add_ssrc(1234); video_sender_info.add_ssrc(1234);
@ -999,7 +999,7 @@ TEST_P(StatsCollectorTrackTest, VideoBandwidthEstimationInfoIsReported) {
pc->AddVideoChannel("video", "transport", video_info); pc->AddVideoChannel("video", "transport", video_info);
AddOutgoingVideoTrack(pc, stats.get()); AddOutgoingVideoTrack(pc.get(), stats.get());
Call::Stats call_stats; Call::Stats call_stats;
call_stats.send_bandwidth_bps = kSendBandwidth; call_stats.send_bandwidth_bps = kSendBandwidth;
@ -1030,7 +1030,7 @@ TEST_P(StatsCollectorTrackTest, VideoBandwidthEstimationInfoIsReported) {
// exists in the returned stats. // exists in the returned stats.
TEST_F(StatsCollectorTest, SessionObjectExists) { TEST_F(StatsCollectorTest, SessionObjectExists) {
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
StatsReports reports; StatsReports reports;
@ -1044,7 +1044,7 @@ TEST_F(StatsCollectorTest, SessionObjectExists) {
// in the returned stats. // in the returned stats.
TEST_F(StatsCollectorTest, OnlyOneSessionObjectExists) { TEST_F(StatsCollectorTest, OnlyOneSessionObjectExists) {
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
@ -1061,10 +1061,10 @@ TEST_F(StatsCollectorTest, OnlyOneSessionObjectExists) {
// without calling StatsCollector::UpdateStats. // without calling StatsCollector::UpdateStats.
TEST_P(StatsCollectorTrackTest, TrackObjectExistsWithoutUpdateStats) { TEST_P(StatsCollectorTrackTest, TrackObjectExistsWithoutUpdateStats) {
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
pc->AddVideoChannel("video", "transport"); pc->AddVideoChannel("video", "transport");
AddOutgoingVideoTrack(pc, stats.get()); AddOutgoingVideoTrack(pc.get(), stats.get());
// Verfies the existence of the track report. // Verfies the existence of the track report.
StatsReports reports; StatsReports reports;
@ -1085,7 +1085,7 @@ TEST_P(StatsCollectorTrackTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
constexpr int64_t kBytesSent = 12345678901234LL; constexpr int64_t kBytesSent = 12345678901234LL;
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
VideoSenderInfo video_sender_info; VideoSenderInfo video_sender_info;
video_sender_info.add_ssrc(1234); video_sender_info.add_ssrc(1234);
@ -1096,7 +1096,7 @@ TEST_P(StatsCollectorTrackTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
pc->AddVideoChannel("video", "transport", video_info); pc->AddVideoChannel("video", "transport", video_info);
AddOutgoingVideoTrack(pc, stats.get()); AddOutgoingVideoTrack(pc.get(), stats.get());
stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
StatsReports reports; StatsReports reports;
@ -1111,7 +1111,7 @@ TEST_P(StatsCollectorTrackTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
// Get report for the specific `track`. // Get report for the specific `track`.
reports.clear(); reports.clear();
stats->GetStats(track_, &reports); stats->GetStats(track_.get(), &reports);
// `reports` should contain at least one session report, one track report, // `reports` should contain at least one session report, one track report,
// and one ssrc report. // and one ssrc report.
EXPECT_LE(3u, reports.size()); EXPECT_LE(3u, reports.size());
@ -1139,7 +1139,7 @@ TEST_P(StatsCollectorTrackTest, TransportObjectLinkedFromSsrcObject) {
constexpr int64_t kBytesSent = 12345678901234LL; constexpr int64_t kBytesSent = 12345678901234LL;
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
VideoSenderInfo video_sender_info; VideoSenderInfo video_sender_info;
video_sender_info.add_ssrc(1234); video_sender_info.add_ssrc(1234);
@ -1150,7 +1150,7 @@ TEST_P(StatsCollectorTrackTest, TransportObjectLinkedFromSsrcObject) {
pc->AddVideoChannel("video", "transport", video_info); pc->AddVideoChannel("video", "transport", video_info);
AddOutgoingVideoTrack(pc, stats.get()); AddOutgoingVideoTrack(pc.get(), stats.get());
stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
StatsReports reports; StatsReports reports;
@ -1181,10 +1181,10 @@ TEST_P(StatsCollectorTrackTest, TransportObjectLinkedFromSsrcObject) {
// an outgoing SSRC where remote stats are not returned. // an outgoing SSRC where remote stats are not returned.
TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsAbsent) { TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsAbsent) {
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
pc->AddVideoChannel("video", "transport"); pc->AddVideoChannel("video", "transport");
AddOutgoingVideoTrack(pc, stats.get()); AddOutgoingVideoTrack(pc.get(), stats.get());
stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
StatsReports reports; StatsReports reports;
@ -1199,7 +1199,7 @@ TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsAbsent) {
// an outgoing SSRC where stats are returned. // an outgoing SSRC where stats are returned.
TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsPresent) { TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsPresent) {
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
SsrcReceiverInfo remote_ssrc_stats; SsrcReceiverInfo remote_ssrc_stats;
remote_ssrc_stats.timestamp = 12345.678; remote_ssrc_stats.timestamp = 12345.678;
@ -1212,7 +1212,7 @@ TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsPresent) {
pc->AddVideoChannel("video", "transport", video_info); pc->AddVideoChannel("video", "transport", video_info);
AddOutgoingVideoTrack(pc, stats.get()); AddOutgoingVideoTrack(pc.get(), stats.get());
stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
StatsReports reports; StatsReports reports;
@ -1230,7 +1230,7 @@ TEST_P(StatsCollectorTrackTest, ReportsFromRemoteTrack) {
constexpr int64_t kNumOfPacketsConcealed = 54321; constexpr int64_t kNumOfPacketsConcealed = 54321;
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
VideoReceiverInfo video_receiver_info; VideoReceiverInfo video_receiver_info;
video_receiver_info.add_ssrc(1234); video_receiver_info.add_ssrc(1234);
@ -1240,7 +1240,7 @@ TEST_P(StatsCollectorTrackTest, ReportsFromRemoteTrack) {
pc->AddVideoChannel("video", "transport", video_info); pc->AddVideoChannel("video", "transport", video_info);
AddIncomingVideoTrack(pc, stats.get()); AddIncomingVideoTrack(pc.get(), stats.get());
stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
StatsReports reports; StatsReports reports;
@ -1279,7 +1279,7 @@ TEST_F(StatsCollectorTest, IceCandidateReport) {
const rtc::SocketAddress kRemoteAddress(kRemoteIp, kRemotePort); const rtc::SocketAddress kRemoteAddress(kRemoteIp, kRemotePort);
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
cricket::Candidate local; cricket::Candidate local;
EXPECT_GT(local.id().length(), 0u); EXPECT_GT(local.id().length(), 0u);
@ -1415,7 +1415,7 @@ TEST_F(StatsCollectorTest, ChainlessCertificateReportsCreated) {
// transport is present. // transport is present.
TEST_F(StatsCollectorTest, NoTransport) { TEST_F(StatsCollectorTest, NoTransport) {
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
// This will cause the fake PeerConnection to generate a TransportStats entry // This will cause the fake PeerConnection to generate a TransportStats entry
// but with only a single dummy TransportChannelStats. // but with only a single dummy TransportChannelStats.
@ -1474,16 +1474,16 @@ TEST_P(StatsCollectorTrackTest, FilterOutNegativeInitialValues) {
} }
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
// Create a local stream with a local audio track and adds it to the stats. // Create a local stream with a local audio track and adds it to the stats.
stream_ = MediaStream::Create("streamid"); stream_ = MediaStream::Create("streamid");
auto local_track = auto local_track =
rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kLocalTrackId); rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kLocalTrackId);
stream_->AddTrack(local_track); stream_->AddTrack(local_track.get());
pc->AddSender(CreateMockSender(local_track, kSsrcOfTrack)); pc->AddSender(CreateMockSender(local_track, kSsrcOfTrack));
if (GetParam()) { if (GetParam()) {
stats->AddStream(stream_); stats->AddStream(stream_.get());
} }
stats->AddLocalAudioTrack(local_track.get(), kSsrcOfTrack); stats->AddLocalAudioTrack(local_track.get(), kSsrcOfTrack);
@ -1492,10 +1492,10 @@ TEST_P(StatsCollectorTrackTest, FilterOutNegativeInitialValues) {
MediaStream::Create("remotestreamid")); MediaStream::Create("remotestreamid"));
auto remote_track = auto remote_track =
rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kRemoteTrackId); rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kRemoteTrackId);
remote_stream->AddTrack(remote_track); remote_stream->AddTrack(remote_track.get());
pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack)); pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
if (GetParam()) { if (GetParam()) {
stats->AddStream(remote_stream); stats->AddStream(remote_stream.get());
} }
VoiceSenderInfo voice_sender_info; VoiceSenderInfo voice_sender_info;
@ -1561,14 +1561,15 @@ TEST_P(StatsCollectorTrackTest, FilterOutNegativeInitialValues) {
// AudioTrackInterface::GetStats() method. // AudioTrackInterface::GetStats() method.
TEST_P(StatsCollectorTrackTest, GetStatsFromLocalAudioTrack) { TEST_P(StatsCollectorTrackTest, GetStatsFromLocalAudioTrack) {
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
AddOutgoingAudioTrack(pc, stats.get()); AddOutgoingAudioTrack(pc.get(), stats.get());
stats->AddLocalAudioTrack(audio_track_, kSsrcOfTrack); stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
VoiceSenderInfo voice_sender_info; VoiceSenderInfo voice_sender_info;
InitVoiceSenderInfo(&voice_sender_info); InitVoiceSenderInfo(&voice_sender_info);
UpdateVoiceSenderInfoFromAudioTrack(audio_track_, &voice_sender_info, false); UpdateVoiceSenderInfoFromAudioTrack(audio_track_.get(), &voice_sender_info,
false);
VoiceMediaInfo voice_info; VoiceMediaInfo voice_info;
voice_info.senders.push_back(voice_sender_info); voice_info.senders.push_back(voice_sender_info);
@ -1576,7 +1577,7 @@ TEST_P(StatsCollectorTrackTest, GetStatsFromLocalAudioTrack) {
voice_media_channel->SetStats(voice_info); voice_media_channel->SetStats(voice_info);
StatsReports reports; // returned values. StatsReports reports; // returned values.
VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports); VerifyAudioTrackStats(audio_track_.get(), stats.get(), voice_info, &reports);
// Verify that there is no remote report for the local audio track because // Verify that there is no remote report for the local audio track because
// we did not set it up. // we did not set it up.
@ -1589,9 +1590,9 @@ TEST_P(StatsCollectorTrackTest, GetStatsFromLocalAudioTrack) {
// correctly. // correctly.
TEST_P(StatsCollectorTrackTest, GetStatsFromRemoteStream) { TEST_P(StatsCollectorTrackTest, GetStatsFromRemoteStream) {
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
AddIncomingAudioTrack(pc, stats.get()); AddIncomingAudioTrack(pc.get(), stats.get());
VoiceReceiverInfo voice_receiver_info; VoiceReceiverInfo voice_receiver_info;
InitVoiceReceiverInfo(&voice_receiver_info); InitVoiceReceiverInfo(&voice_receiver_info);
@ -1603,16 +1604,16 @@ TEST_P(StatsCollectorTrackTest, GetStatsFromRemoteStream) {
voice_media_channel->SetStats(voice_info); voice_media_channel->SetStats(voice_info);
StatsReports reports; // returned values. StatsReports reports; // returned values.
VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports); VerifyAudioTrackStats(audio_track_.get(), stats.get(), voice_info, &reports);
} }
// This test verifies that a local stats object won't update its statistics // This test verifies that a local stats object won't update its statistics
// after a RemoveLocalAudioTrack() call. // after a RemoveLocalAudioTrack() call.
TEST_P(StatsCollectorTrackTest, GetStatsAfterRemoveAudioStream) { TEST_P(StatsCollectorTrackTest, GetStatsAfterRemoveAudioStream) {
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
AddOutgoingAudioTrack(pc, stats.get()); AddOutgoingAudioTrack(pc.get(), stats.get());
stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack); stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
VoiceSenderInfo voice_sender_info; VoiceSenderInfo voice_sender_info;
@ -1651,10 +1652,10 @@ TEST_P(StatsCollectorTrackTest, GetStatsAfterRemoveAudioStream) {
// the same ssrc, they populate stats reports correctly. // the same ssrc, they populate stats reports correctly.
TEST_P(StatsCollectorTrackTest, LocalAndRemoteTracksWithSameSsrc) { TEST_P(StatsCollectorTrackTest, LocalAndRemoteTracksWithSameSsrc) {
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
// Create a local stream with a local audio track and adds it to the stats. // Create a local stream with a local audio track and adds it to the stats.
AddOutgoingAudioTrack(pc, stats.get()); AddOutgoingAudioTrack(pc.get(), stats.get());
stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack); stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
// Create a remote stream with a remote audio track and adds it to the stats. // Create a remote stream with a remote audio track and adds it to the stats.
@ -1662,8 +1663,8 @@ TEST_P(StatsCollectorTrackTest, LocalAndRemoteTracksWithSameSsrc) {
MediaStream::Create("remotestreamid")); MediaStream::Create("remotestreamid"));
auto remote_track = rtc::make_ref_counted<FakeAudioTrack>(kRemoteTrackId); auto remote_track = rtc::make_ref_counted<FakeAudioTrack>(kRemoteTrackId);
pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack)); pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
remote_stream->AddTrack(remote_track); remote_stream->AddTrack(remote_track.get());
stats->AddStream(remote_stream); stats->AddStream(remote_stream.get());
VoiceSenderInfo voice_sender_info; VoiceSenderInfo voice_sender_info;
InitVoiceSenderInfo(&voice_sender_info); InitVoiceSenderInfo(&voice_sender_info);
@ -1723,15 +1724,16 @@ TEST_P(StatsCollectorTrackTest, TwoLocalTracksWithSameSsrc) {
} }
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
// Create a local stream with a local audio track and adds it to the stats. // Create a local stream with a local audio track and adds it to the stats.
auto sender = AddOutgoingAudioTrack(pc, stats.get()); auto sender = AddOutgoingAudioTrack(pc.get(), stats.get());
stats->AddLocalAudioTrack(audio_track_, kSsrcOfTrack); stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
VoiceSenderInfo voice_sender_info; VoiceSenderInfo voice_sender_info;
InitVoiceSenderInfo(&voice_sender_info); InitVoiceSenderInfo(&voice_sender_info);
UpdateVoiceSenderInfoFromAudioTrack(audio_track_, &voice_sender_info, false); UpdateVoiceSenderInfoFromAudioTrack(audio_track_.get(), &voice_sender_info,
false);
voice_sender_info.add_ssrc(kSsrcOfTrack); voice_sender_info.add_ssrc(kSsrcOfTrack);
VoiceMediaInfo voice_info; VoiceMediaInfo voice_info;
voice_info.senders.push_back(voice_sender_info); voice_info.senders.push_back(voice_sender_info);
@ -1740,7 +1742,7 @@ TEST_P(StatsCollectorTrackTest, TwoLocalTracksWithSameSsrc) {
voice_media_channel->SetStats(voice_info); voice_media_channel->SetStats(voice_info);
StatsReports reports; // returned values. StatsReports reports; // returned values.
VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports); VerifyAudioTrackStats(audio_track_.get(), stats.get(), voice_info, &reports);
// Remove the previous audio track from the stream. // Remove the previous audio track from the stream.
stream_->RemoveTrack(audio_track_.get()); stream_->RemoveTrack(audio_track_.get());
@ -1751,21 +1753,22 @@ TEST_P(StatsCollectorTrackTest, TwoLocalTracksWithSameSsrc) {
static const std::string kNewTrackId = "new_track_id"; static const std::string kNewTrackId = "new_track_id";
auto new_audio_track = rtc::make_ref_counted<FakeAudioTrack>(kNewTrackId); auto new_audio_track = rtc::make_ref_counted<FakeAudioTrack>(kNewTrackId);
pc->AddSender(CreateMockSender(new_audio_track, kSsrcOfTrack)); pc->AddSender(CreateMockSender(new_audio_track, kSsrcOfTrack));
stream_->AddTrack(new_audio_track); stream_->AddTrack(new_audio_track.get());
stats->AddLocalAudioTrack(new_audio_track, kSsrcOfTrack); stats->AddLocalAudioTrack(new_audio_track.get(), kSsrcOfTrack);
stats->InvalidateCache(); stats->InvalidateCache();
VoiceSenderInfo new_voice_sender_info; VoiceSenderInfo new_voice_sender_info;
InitVoiceSenderInfo(&new_voice_sender_info); InitVoiceSenderInfo(&new_voice_sender_info);
UpdateVoiceSenderInfoFromAudioTrack(new_audio_track, &new_voice_sender_info, UpdateVoiceSenderInfoFromAudioTrack(new_audio_track.get(),
false); &new_voice_sender_info, false);
VoiceMediaInfo new_voice_info; VoiceMediaInfo new_voice_info;
new_voice_info.senders.push_back(new_voice_sender_info); new_voice_info.senders.push_back(new_voice_sender_info);
voice_media_channel->SetStats(new_voice_info); voice_media_channel->SetStats(new_voice_info);
reports.clear(); reports.clear();
VerifyAudioTrackStats(new_audio_track, stats.get(), new_voice_info, &reports); VerifyAudioTrackStats(new_audio_track.get(), stats.get(), new_voice_info,
&reports);
} }
// Test that if there are two local senders with the same track then two SSRC // Test that if there are two local senders with the same track then two SSRC
@ -1776,7 +1779,7 @@ TEST_P(StatsCollectorTrackTest, TwoLocalSendersWithSameTrack) {
constexpr uint32_t kSecondSsrc = 33; constexpr uint32_t kSecondSsrc = 33;
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
auto local_track = auto local_track =
rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kLocalTrackId); rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kLocalTrackId);
@ -1836,9 +1839,9 @@ TEST_P(StatsCollectorTrackTest, TwoLocalSendersWithSameTrack) {
// This test verifies that stats are correctly set in video send ssrc stats. // This test verifies that stats are correctly set in video send ssrc stats.
TEST_P(StatsCollectorTrackTest, VerifyVideoSendSsrcStats) { TEST_P(StatsCollectorTrackTest, VerifyVideoSendSsrcStats) {
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
AddOutgoingVideoTrack(pc, stats.get()); AddOutgoingVideoTrack(pc.get(), stats.get());
VideoSenderInfo video_sender_info; VideoSenderInfo video_sender_info;
video_sender_info.add_ssrc(1234); video_sender_info.add_ssrc(1234);
@ -1863,9 +1866,9 @@ TEST_P(StatsCollectorTrackTest, VerifyVideoSendSsrcStats) {
// This test verifies that stats are correctly set in video receive ssrc stats. // This test verifies that stats are correctly set in video receive ssrc stats.
TEST_P(StatsCollectorTrackTest, VerifyVideoReceiveSsrcStatsNew) { TEST_P(StatsCollectorTrackTest, VerifyVideoReceiveSsrcStatsNew) {
auto pc = CreatePeerConnection(); auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc); auto stats = CreateStatsCollector(pc.get());
AddIncomingVideoTrack(pc, stats.get()); AddIncomingVideoTrack(pc.get(), stats.get());
VideoReceiverInfo video_receiver_info; VideoReceiverInfo video_receiver_info;
video_receiver_info.add_ssrc(1234); video_receiver_info.add_ssrc(1234);

10
pc/stream_collection.h
View File

@ -34,14 +34,14 @@ class StreamCollection : public StreamCollectionInterface {
virtual size_t count() { return media_streams_.size(); } virtual size_t count() { return media_streams_.size(); }
virtual MediaStreamInterface* at(size_t index) { virtual MediaStreamInterface* at(size_t index) {
return media_streams_.at(index); return media_streams_.at(index).get();
} }
virtual MediaStreamInterface* find(const std::string& id) { virtual MediaStreamInterface* find(const std::string& id) {
for (StreamVector::iterator it = media_streams_.begin(); for (StreamVector::iterator it = media_streams_.begin();
it != media_streams_.end(); ++it) { it != media_streams_.end(); ++it) {
if ((*it)->id().compare(id) == 0) { if ((*it)->id().compare(id) == 0) {
return (*it); return (*it).get();
} }
} }
return NULL; return NULL;
@ -49,7 +49,8 @@ class StreamCollection : public StreamCollectionInterface {
virtual MediaStreamTrackInterface* FindAudioTrack(const std::string& id) { virtual MediaStreamTrackInterface* FindAudioTrack(const std::string& id) {
for (size_t i = 0; i < media_streams_.size(); ++i) { for (size_t i = 0; i < media_streams_.size(); ++i) {
MediaStreamTrackInterface* track = media_streams_[i]->FindAudioTrack(id); MediaStreamTrackInterface* track =
media_streams_[i]->FindAudioTrack(id).get();
if (track) { if (track) {
return track; return track;
} }
@ -59,7 +60,8 @@ class StreamCollection : public StreamCollectionInterface {
virtual MediaStreamTrackInterface* FindVideoTrack(const std::string& id) { virtual MediaStreamTrackInterface* FindVideoTrack(const std::string& id) {
for (size_t i = 0; i < media_streams_.size(); ++i) { for (size_t i = 0; i < media_streams_.size(); ++i) {
MediaStreamTrackInterface* track = media_streams_[i]->FindVideoTrack(id); MediaStreamTrackInterface* track =
media_streams_[i]->FindVideoTrack(id).get();
if (track) { if (track) {
return track; return track;
} }

4
pc/test/fake_peer_connection_for_stats.h
View File

@ -180,7 +180,7 @@ class FakePeerConnectionForStats : public FakePeerConnectionBase {
void RemoveSender(rtc::scoped_refptr<RtpSenderInterface> sender) { void RemoveSender(rtc::scoped_refptr<RtpSenderInterface> sender) {
GetOrCreateFirstTransceiverOfType(sender->media_type()) GetOrCreateFirstTransceiverOfType(sender->media_type())
->internal() ->internal()
->RemoveSender(sender); ->RemoveSender(sender.get());
} }
rtc::scoped_refptr<RtpReceiverInterface> AddReceiver( rtc::scoped_refptr<RtpReceiverInterface> AddReceiver(
@ -198,7 +198,7 @@ class FakePeerConnectionForStats : public FakePeerConnectionBase {
void RemoveReceiver(rtc::scoped_refptr<RtpReceiverInterface> receiver) { void RemoveReceiver(rtc::scoped_refptr<RtpReceiverInterface> receiver) {
GetOrCreateFirstTransceiverOfType(receiver->media_type()) GetOrCreateFirstTransceiverOfType(receiver->media_type())
->internal() ->internal()
->RemoveReceiver(receiver); ->RemoveReceiver(receiver.get());
} }
FakeVoiceMediaChannelForStats* AddVoiceChannel( FakeVoiceMediaChannelForStats* AddVoiceChannel(

36
pc/test/integration_test_helpers.h
View File

@ -346,7 +346,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
// TODO(perkj): Test audio source when it is implemented. Currently audio // TODO(perkj): Test audio source when it is implemented. Currently audio
// always use the default input. // always use the default input.
return peer_connection_factory_->CreateAudioTrack(rtc::CreateRandomUuid(), return peer_connection_factory_->CreateAudioTrack(rtc::CreateRandomUuid(),
source); source.get());
} }
rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrack() { rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrack() {
@ -415,7 +415,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
data_channels_.push_back(data_channel_or_error.MoveValue()); data_channels_.push_back(data_channel_or_error.MoveValue());
ASSERT_TRUE(data_channels_.back().get() != nullptr); ASSERT_TRUE(data_channels_.back().get() != nullptr);
data_observers_.push_back( data_observers_.push_back(
std::make_unique<MockDataChannelObserver>(data_channels_.back())); std::make_unique<MockDataChannelObserver>(data_channels_.back().get()));
} }
// Return the last observed data channel. // Return the last observed data channel.
@ -423,7 +423,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
if (data_channels_.size() == 0) { if (data_channels_.size() == 0) {
return nullptr; return nullptr;
} }
return data_channels_.back(); return data_channels_.back().get();
} }
// Return all data channels. // Return all data channels.
const std::vector<rtc::scoped_refptr<DataChannelInterface>>& data_channels() { const std::vector<rtc::scoped_refptr<DataChannelInterface>>& data_channels() {
@ -466,7 +466,8 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
webrtc::MediaStreamTrackInterface* track) { webrtc::MediaStreamTrackInterface* track) {
auto observer = rtc::make_ref_counted<MockStatsObserver>(); auto observer = rtc::make_ref_counted<MockStatsObserver>();
EXPECT_TRUE(peer_connection_->GetStats( EXPECT_TRUE(peer_connection_->GetStats(
observer, nullptr, PeerConnectionInterface::kStatsOutputLevelStandard)); observer.get(), nullptr,
PeerConnectionInterface::kStatsOutputLevelStandard));
EXPECT_TRUE_WAIT(observer->called(), kDefaultTimeout); EXPECT_TRUE_WAIT(observer->called(), kDefaultTimeout);
return observer; return observer;
} }
@ -481,7 +482,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
rtc::scoped_refptr<const webrtc::RTCStatsReport> NewGetStats() { rtc::scoped_refptr<const webrtc::RTCStatsReport> NewGetStats() {
auto callback = auto callback =
rtc::make_ref_counted<webrtc::MockRTCStatsCollectorCallback>(); rtc::make_ref_counted<webrtc::MockRTCStatsCollectorCallback>();
peer_connection_->GetStats(callback); peer_connection_->GetStats(callback.get());
EXPECT_TRUE_WAIT(callback->called(), kDefaultTimeout); EXPECT_TRUE_WAIT(callback->called(), kDefaultTimeout);
return callback->report(); return callback->report();
} }
@ -542,7 +543,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
ADD_FAILURE(); ADD_FAILURE();
return nullptr; return nullptr;
} }
return pc()->remote_streams(); return pc()->remote_streams().get();
} }
StreamCollectionInterface* local_streams() { StreamCollectionInterface* local_streams() {
@ -550,7 +551,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
ADD_FAILURE(); ADD_FAILURE();
return nullptr; return nullptr;
} }
return pc()->local_streams(); return pc()->local_streams().get();
} }
webrtc::PeerConnectionInterface::SignalingState signaling_state() { webrtc::PeerConnectionInterface::SignalingState signaling_state() {
@ -619,8 +620,8 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
std::unique_ptr<SessionDescriptionInterface> CreateOfferAndWait() { std::unique_ptr<SessionDescriptionInterface> CreateOfferAndWait() {
auto observer = auto observer =
rtc::make_ref_counted<MockCreateSessionDescriptionObserver>(); rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
pc()->CreateOffer(observer, offer_answer_options_); pc()->CreateOffer(observer.get(), offer_answer_options_);
return WaitForDescriptionFromObserver(observer); return WaitForDescriptionFromObserver(observer.get());
} }
bool Rollback() { bool Rollback() {
return SetRemoteDescription( return SetRemoteDescription(
@ -856,9 +857,10 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
config, false /* remote */)); config, false /* remote */));
rtc::scoped_refptr<webrtc::VideoTrackInterface> track( rtc::scoped_refptr<webrtc::VideoTrackInterface> track(
peer_connection_factory_->CreateVideoTrack( peer_connection_factory_->CreateVideoTrack(
rtc::CreateRandomUuid(), video_track_sources_.back())); rtc::CreateRandomUuid(), video_track_sources_.back().get()));
if (!local_video_renderer_) { if (!local_video_renderer_) {
local_video_renderer_.reset(new webrtc::FakeVideoTrackRenderer(track)); local_video_renderer_.reset(
new webrtc::FakeVideoTrackRenderer(track.get()));
} }
return track; return track;
} }
@ -900,8 +902,8 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
std::unique_ptr<SessionDescriptionInterface> CreateAnswer() { std::unique_ptr<SessionDescriptionInterface> CreateAnswer() {
auto observer = auto observer =
rtc::make_ref_counted<MockCreateSessionDescriptionObserver>(); rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
pc()->CreateAnswer(observer, offer_answer_options_); pc()->CreateAnswer(observer.get(), offer_answer_options_);
return WaitForDescriptionFromObserver(observer); return WaitForDescriptionFromObserver(observer.get());
} }
std::unique_ptr<SessionDescriptionInterface> WaitForDescriptionFromObserver( std::unique_ptr<SessionDescriptionInterface> WaitForDescriptionFromObserver(
@ -930,7 +932,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
std::string sdp; std::string sdp;
EXPECT_TRUE(desc->ToString(&sdp)); EXPECT_TRUE(desc->ToString(&sdp));
RTC_LOG(LS_INFO) << debug_name_ << ": local SDP contents=\n" << sdp; RTC_LOG(LS_INFO) << debug_name_ << ": local SDP contents=\n" << sdp;
pc()->SetLocalDescription(observer, desc.release()); pc()->SetLocalDescription(observer.get(), desc.release());
RemoveUnusedVideoRenderers(); RemoveUnusedVideoRenderers();
// As mentioned above, we need to send the message immediately after // As mentioned above, we need to send the message immediately after
// SetLocalDescription. // SetLocalDescription.
@ -942,7 +944,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
bool SetRemoteDescription(std::unique_ptr<SessionDescriptionInterface> desc) { bool SetRemoteDescription(std::unique_ptr<SessionDescriptionInterface> desc) {
auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>(); auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
RTC_LOG(LS_INFO) << debug_name_ << ": SetRemoteDescription"; RTC_LOG(LS_INFO) << debug_name_ << ": SetRemoteDescription";
pc()->SetRemoteDescription(observer, desc.release()); pc()->SetRemoteDescription(observer.get(), desc.release());
RemoveUnusedVideoRenderers(); RemoveUnusedVideoRenderers();
EXPECT_TRUE_WAIT(observer->called(), kDefaultTimeout); EXPECT_TRUE_WAIT(observer->called(), kDefaultTimeout);
return observer->result(); return observer->result();
@ -1056,7 +1058,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
ASSERT_TRUE(fake_video_renderers_.find(video_track->id()) == ASSERT_TRUE(fake_video_renderers_.find(video_track->id()) ==
fake_video_renderers_.end()); fake_video_renderers_.end());
fake_video_renderers_[video_track->id()] = fake_video_renderers_[video_track->id()] =
std::make_unique<FakeVideoTrackRenderer>(video_track); std::make_unique<FakeVideoTrackRenderer>(video_track.get());
} }
} }
void OnRemoveTrack( void OnRemoveTrack(
@ -1139,7 +1141,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
RTC_LOG(LS_INFO) << debug_name_ << ": OnDataChannel"; RTC_LOG(LS_INFO) << debug_name_ << ": OnDataChannel";
data_channels_.push_back(data_channel); data_channels_.push_back(data_channel);
data_observers_.push_back( data_observers_.push_back(
std::make_unique<MockDataChannelObserver>(data_channel)); std::make_unique<MockDataChannelObserver>(data_channel.get()));
} }
std::string debug_name_; std::string debug_name_;

6
pc/test/mock_peer_connection_observers.h
View File

@ -74,7 +74,9 @@ class MockPeerConnectionObserver : public PeerConnectionObserver {
MediaStreamInterface* RemoteStream(const std::string& label) { MediaStreamInterface* RemoteStream(const std::string& label) {
return remote_streams_->find(label); return remote_streams_->find(label);
} }
StreamCollectionInterface* remote_streams() const { return remote_streams_; } StreamCollectionInterface* remote_streams() const {
return remote_streams_.get();
}
void OnAddStream(rtc::scoped_refptr<MediaStreamInterface> stream) override { void OnAddStream(rtc::scoped_refptr<MediaStreamInterface> stream) override {
last_added_stream_ = stream; last_added_stream_ = stream;
remote_streams_->AddStream(stream); remote_streams_->AddStream(stream);
@ -82,7 +84,7 @@ class MockPeerConnectionObserver : public PeerConnectionObserver {
void OnRemoveStream( void OnRemoveStream(
rtc::scoped_refptr<MediaStreamInterface> stream) override { rtc::scoped_refptr<MediaStreamInterface> stream) override {
last_removed_stream_ = stream; last_removed_stream_ = stream;
remote_streams_->RemoveStream(stream); remote_streams_->RemoveStream(stream.get());
} }
void OnRenegotiationNeeded() override { renegotiation_needed_ = true; } void OnRenegotiationNeeded() override { renegotiation_needed_ = true; }
void OnNegotiationNeededEvent(uint32_t event_id) override { void OnNegotiationNeededEvent(uint32_t event_id) override {

17
pc/test/peer_connection_test_wrapper.cc
View File

@ -106,7 +106,7 @@ bool PeerConnectionTestWrapper::CreatePc(
RTC_DCHECK_RUN_ON(&pc_thread_checker_); RTC_DCHECK_RUN_ON(&pc_thread_checker_);
fake_audio_capture_module_ = FakeAudioCaptureModule::Create(); fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
if (fake_audio_capture_module_ == NULL) { if (fake_audio_capture_module_ == nullptr) {
return false; return false;
} }
@ -184,7 +184,7 @@ void PeerConnectionTestWrapper::OnIceCandidate(
void PeerConnectionTestWrapper::OnDataChannel( void PeerConnectionTestWrapper::OnDataChannel(
rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) { rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
SignalOnDataChannel(data_channel); SignalOnDataChannel(data_channel.get());
} }
void PeerConnectionTestWrapper::OnSuccess(SessionDescriptionInterface* desc) { void PeerConnectionTestWrapper::OnSuccess(SessionDescriptionInterface* desc) {
@ -237,7 +237,7 @@ void PeerConnectionTestWrapper::SetLocalDescription(SdpType type,
auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>(); auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
peer_connection_->SetLocalDescription( peer_connection_->SetLocalDescription(
observer, webrtc::CreateSessionDescription(type, sdp).release()); observer.get(), webrtc::CreateSessionDescription(type, sdp).release());
} }
void PeerConnectionTestWrapper::SetRemoteDescription(SdpType type, void PeerConnectionTestWrapper::SetRemoteDescription(SdpType type,
@ -248,7 +248,7 @@ void PeerConnectionTestWrapper::SetRemoteDescription(SdpType type,
auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>(); auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
peer_connection_->SetRemoteDescription( peer_connection_->SetRemoteDescription(
observer, webrtc::CreateSessionDescription(type, sdp).release()); observer.get(), webrtc::CreateSessionDescription(type, sdp).release());
} }
void PeerConnectionTestWrapper::AddIceCandidate(const std::string& sdp_mid, void PeerConnectionTestWrapper::AddIceCandidate(const std::string& sdp_mid,
@ -333,8 +333,8 @@ PeerConnectionTestWrapper::GetUserMedia(
peer_connection_factory_->CreateAudioSource(options); peer_connection_factory_->CreateAudioSource(options);
rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track( rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
peer_connection_factory_->CreateAudioTrack(kAudioTrackLabelBase, peer_connection_factory_->CreateAudioTrack(kAudioTrackLabelBase,
source)); source.get()));
stream->AddTrack(audio_track); stream->AddTrack(audio_track.get());
} }
if (video) { if (video) {
@ -348,9 +348,10 @@ PeerConnectionTestWrapper::GetUserMedia(
std::string videotrack_label = stream_id + kVideoTrackLabelBase; std::string videotrack_label = stream_id + kVideoTrackLabelBase;
rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track( rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
peer_connection_factory_->CreateVideoTrack(videotrack_label, source)); peer_connection_factory_->CreateVideoTrack(videotrack_label,
source.get()));
stream->AddTrack(video_track); stream->AddTrack(video_track.get());
} }
return stream; return stream;
} }

8
pc/track_media_info_map.cc
View File

@ -52,7 +52,7 @@ void GetAudioAndVideoTrackBySsrc(
RTC_DCHECK(remote_video_track_by_ssrc->empty()); RTC_DCHECK(remote_video_track_by_ssrc->empty());
for (const auto& rtp_sender : rtp_senders) { for (const auto& rtp_sender : rtp_senders) {
cricket::MediaType media_type = rtp_sender->media_type(); cricket::MediaType media_type = rtp_sender->media_type();
MediaStreamTrackInterface* track = rtp_sender->track(); MediaStreamTrackInterface* track = rtp_sender->track().get();
if (!track) { if (!track) {
continue; continue;
} }
@ -74,7 +74,7 @@ void GetAudioAndVideoTrackBySsrc(
} }
for (const auto& rtp_receiver : rtp_receivers) { for (const auto& rtp_receiver : rtp_receivers) {
cricket::MediaType media_type = rtp_receiver->media_type(); cricket::MediaType media_type = rtp_receiver->media_type();
MediaStreamTrackInterface* track = rtp_receiver->track(); MediaStreamTrackInterface* track = rtp_receiver->track().get();
RTC_DCHECK(track); RTC_DCHECK(track);
RtpParameters params = rtp_receiver->GetParameters(); RtpParameters params = rtp_receiver->GetParameters();
for (const RtpEncodingParameters& encoding : params.encodings) { for (const RtpEncodingParameters& encoding : params.encodings) {
@ -126,10 +126,10 @@ TrackMediaInfoMap::TrackMediaInfoMap(
&unsignaled_video_track); &unsignaled_video_track);
for (const auto& sender : rtp_senders) { for (const auto& sender : rtp_senders) {
attachment_id_by_track_[sender->track()] = sender->AttachmentId(); attachment_id_by_track_[sender->track().get()] = sender->AttachmentId();
} }
for (const auto& receiver : rtp_receivers) { for (const auto& receiver : rtp_receivers) {
attachment_id_by_track_[receiver->track()] = receiver->AttachmentId(); attachment_id_by_track_[receiver->track().get()] = receiver->AttachmentId();
} }
if (voice_media_info_) { if (voice_media_info_) {

83
pc/track_media_info_map_unittest.cc
View File

@ -205,10 +205,10 @@ class TrackMediaInfoMapTest : public ::testing::Test {
} // namespace } // namespace
TEST_F(TrackMediaInfoMapTest, SingleSenderReceiverPerTrackWithOneSsrc) { TEST_F(TrackMediaInfoMapTest, SingleSenderReceiverPerTrackWithOneSsrc) {
AddRtpSenderWithSsrcs({1}, local_audio_track_); AddRtpSenderWithSsrcs({1}, local_audio_track_.get());
AddRtpReceiverWithSsrcs({2}, remote_audio_track_); AddRtpReceiverWithSsrcs({2}, remote_audio_track_.get());
AddRtpSenderWithSsrcs({3}, local_video_track_); AddRtpSenderWithSsrcs({3}, local_video_track_.get());
AddRtpReceiverWithSsrcs({4}, remote_video_track_); AddRtpReceiverWithSsrcs({4}, remote_video_track_.get());
CreateMap(); CreateMap();
// Local audio track <-> RTP audio sender // Local audio track <-> RTP audio sender
@ -241,10 +241,10 @@ TEST_F(TrackMediaInfoMapTest, SingleSenderReceiverPerTrackWithOneSsrc) {
} }
TEST_F(TrackMediaInfoMapTest, SingleSenderReceiverPerTrackWithMissingSsrc) { TEST_F(TrackMediaInfoMapTest, SingleSenderReceiverPerTrackWithMissingSsrc) {
AddRtpSenderWithSsrcs({}, local_audio_track_); AddRtpSenderWithSsrcs({}, local_audio_track_.get());
AddRtpSenderWithSsrcs({}, local_video_track_); AddRtpSenderWithSsrcs({}, local_video_track_.get());
AddRtpReceiverWithSsrcs({}, remote_audio_track_); AddRtpReceiverWithSsrcs({}, remote_audio_track_.get());
AddRtpReceiverWithSsrcs({}, remote_video_track_); AddRtpReceiverWithSsrcs({}, remote_video_track_.get());
CreateMap(); CreateMap();
EXPECT_FALSE(map_->GetVoiceSenderInfos(*local_audio_track_)); EXPECT_FALSE(map_->GetVoiceSenderInfos(*local_audio_track_));
@ -255,10 +255,10 @@ TEST_F(TrackMediaInfoMapTest, SingleSenderReceiverPerTrackWithMissingSsrc) {
TEST_F(TrackMediaInfoMapTest, TEST_F(TrackMediaInfoMapTest,
SingleSenderReceiverPerTrackWithAudioAndVideoUseSameSsrc) { SingleSenderReceiverPerTrackWithAudioAndVideoUseSameSsrc) {
AddRtpSenderWithSsrcs({1}, local_audio_track_); AddRtpSenderWithSsrcs({1}, local_audio_track_.get());
AddRtpReceiverWithSsrcs({2}, remote_audio_track_); AddRtpReceiverWithSsrcs({2}, remote_audio_track_.get());
AddRtpSenderWithSsrcs({1}, local_video_track_); AddRtpSenderWithSsrcs({1}, local_video_track_.get());
AddRtpReceiverWithSsrcs({2}, remote_video_track_); AddRtpReceiverWithSsrcs({2}, remote_video_track_.get());
CreateMap(); CreateMap();
// Local audio track <-> RTP audio sender // Local audio track <-> RTP audio sender
@ -291,8 +291,8 @@ TEST_F(TrackMediaInfoMapTest,
} }
TEST_F(TrackMediaInfoMapTest, SingleMultiSsrcSenderPerTrack) { TEST_F(TrackMediaInfoMapTest, SingleMultiSsrcSenderPerTrack) {
AddRtpSenderWithSsrcs({1, 2}, local_audio_track_); AddRtpSenderWithSsrcs({1, 2}, local_audio_track_.get());
AddRtpSenderWithSsrcs({3, 4}, local_video_track_); AddRtpSenderWithSsrcs({3, 4}, local_video_track_.get());
CreateMap(); CreateMap();
// Local audio track <-> RTP audio senders // Local audio track <-> RTP audio senders
@ -313,10 +313,10 @@ TEST_F(TrackMediaInfoMapTest, SingleMultiSsrcSenderPerTrack) {
} }
TEST_F(TrackMediaInfoMapTest, MultipleOneSsrcSendersPerTrack) { TEST_F(TrackMediaInfoMapTest, MultipleOneSsrcSendersPerTrack) {
AddRtpSenderWithSsrcs({1}, local_audio_track_); AddRtpSenderWithSsrcs({1}, local_audio_track_.get());
AddRtpSenderWithSsrcs({2}, local_audio_track_); AddRtpSenderWithSsrcs({2}, local_audio_track_.get());
AddRtpSenderWithSsrcs({3}, local_video_track_); AddRtpSenderWithSsrcs({3}, local_video_track_.get());
AddRtpSenderWithSsrcs({4}, local_video_track_); AddRtpSenderWithSsrcs({4}, local_video_track_.get());
CreateMap(); CreateMap();
// Local audio track <-> RTP audio senders // Local audio track <-> RTP audio senders
@ -343,10 +343,10 @@ TEST_F(TrackMediaInfoMapTest, MultipleOneSsrcSendersPerTrack) {
} }
TEST_F(TrackMediaInfoMapTest, MultipleMultiSsrcSendersPerTrack) { TEST_F(TrackMediaInfoMapTest, MultipleMultiSsrcSendersPerTrack) {
AddRtpSenderWithSsrcs({1, 2}, local_audio_track_); AddRtpSenderWithSsrcs({1, 2}, local_audio_track_.get());
AddRtpSenderWithSsrcs({3, 4}, local_audio_track_); AddRtpSenderWithSsrcs({3, 4}, local_audio_track_.get());
AddRtpSenderWithSsrcs({5, 6}, local_video_track_); AddRtpSenderWithSsrcs({5, 6}, local_video_track_.get());
AddRtpSenderWithSsrcs({7, 8}, local_video_track_); AddRtpSenderWithSsrcs({7, 8}, local_video_track_.get());
CreateMap(); CreateMap();
// Local audio track <-> RTP audio senders // Local audio track <-> RTP audio senders
@ -374,10 +374,10 @@ TEST_F(TrackMediaInfoMapTest, MultipleMultiSsrcSendersPerTrack) {
// SSRCs can be reused for send and receive in loopback. // SSRCs can be reused for send and receive in loopback.
TEST_F(TrackMediaInfoMapTest, SingleSenderReceiverPerTrackWithSsrcNotUnique) { TEST_F(TrackMediaInfoMapTest, SingleSenderReceiverPerTrackWithSsrcNotUnique) {
AddRtpSenderWithSsrcs({1}, local_audio_track_); AddRtpSenderWithSsrcs({1}, local_audio_track_.get());
AddRtpReceiverWithSsrcs({1}, remote_audio_track_); AddRtpReceiverWithSsrcs({1}, remote_audio_track_.get());
AddRtpSenderWithSsrcs({2}, local_video_track_); AddRtpSenderWithSsrcs({2}, local_video_track_.get());
AddRtpReceiverWithSsrcs({2}, remote_video_track_); AddRtpReceiverWithSsrcs({2}, remote_video_track_.get());
CreateMap(); CreateMap();
// Local audio track <-> RTP audio senders // Local audio track <-> RTP audio senders
@ -410,10 +410,10 @@ TEST_F(TrackMediaInfoMapTest, SingleSenderReceiverPerTrackWithSsrcNotUnique) {
} }
TEST_F(TrackMediaInfoMapTest, SsrcLookupFunction) { TEST_F(TrackMediaInfoMapTest, SsrcLookupFunction) {
AddRtpSenderWithSsrcs({1}, local_audio_track_); AddRtpSenderWithSsrcs({1}, local_audio_track_.get());
AddRtpReceiverWithSsrcs({2}, remote_audio_track_); AddRtpReceiverWithSsrcs({2}, remote_audio_track_.get());
AddRtpSenderWithSsrcs({3}, local_video_track_); AddRtpSenderWithSsrcs({3}, local_video_track_.get());
AddRtpReceiverWithSsrcs({4}, remote_video_track_); AddRtpReceiverWithSsrcs({4}, remote_video_track_.get());
CreateMap(); CreateMap();
EXPECT_TRUE(map_->GetVoiceSenderInfoBySsrc(1)); EXPECT_TRUE(map_->GetVoiceSenderInfoBySsrc(1));
EXPECT_TRUE(map_->GetVoiceReceiverInfoBySsrc(2)); EXPECT_TRUE(map_->GetVoiceReceiverInfoBySsrc(2));
@ -424,11 +424,12 @@ TEST_F(TrackMediaInfoMapTest, SsrcLookupFunction) {
} }
TEST_F(TrackMediaInfoMapTest, GetAttachmentIdByTrack) { TEST_F(TrackMediaInfoMapTest, GetAttachmentIdByTrack) {
AddRtpSenderWithSsrcs({1}, local_audio_track_); AddRtpSenderWithSsrcs({1}, local_audio_track_.get());
CreateMap(); CreateMap();
EXPECT_EQ(rtp_senders_[0]->AttachmentId(), EXPECT_EQ(rtp_senders_[0]->AttachmentId(),
map_->GetAttachmentIdByTrack(local_audio_track_)); map_->GetAttachmentIdByTrack(local_audio_track_.get()));
EXPECT_EQ(absl::nullopt, map_->GetAttachmentIdByTrack(local_video_track_)); EXPECT_EQ(absl::nullopt,
map_->GetAttachmentIdByTrack(local_video_track_.get()));
} }
// Death tests. // Death tests.
@ -442,18 +443,18 @@ class TrackMediaInfoMapDeathTest : public TrackMediaInfoMapTest {
}; };
TEST_F(TrackMediaInfoMapDeathTest, MultipleOneSsrcReceiversPerTrack) { TEST_F(TrackMediaInfoMapDeathTest, MultipleOneSsrcReceiversPerTrack) {
AddRtpReceiverWithSsrcs({1}, remote_audio_track_); AddRtpReceiverWithSsrcs({1}, remote_audio_track_.get());
AddRtpReceiverWithSsrcs({2}, remote_audio_track_); AddRtpReceiverWithSsrcs({2}, remote_audio_track_.get());
AddRtpReceiverWithSsrcs({3}, remote_video_track_); AddRtpReceiverWithSsrcs({3}, remote_video_track_.get());
AddRtpReceiverWithSsrcs({4}, remote_video_track_); AddRtpReceiverWithSsrcs({4}, remote_video_track_.get());
EXPECT_DEATH(CreateMap(), ""); EXPECT_DEATH(CreateMap(), "");
} }
TEST_F(TrackMediaInfoMapDeathTest, MultipleMultiSsrcReceiversPerTrack) { TEST_F(TrackMediaInfoMapDeathTest, MultipleMultiSsrcReceiversPerTrack) {
AddRtpReceiverWithSsrcs({1, 2}, remote_audio_track_); AddRtpReceiverWithSsrcs({1, 2}, remote_audio_track_.get());
AddRtpReceiverWithSsrcs({3, 4}, remote_audio_track_); AddRtpReceiverWithSsrcs({3, 4}, remote_audio_track_.get());
AddRtpReceiverWithSsrcs({5, 6}, remote_video_track_); AddRtpReceiverWithSsrcs({5, 6}, remote_video_track_.get());
AddRtpReceiverWithSsrcs({7, 8}, remote_video_track_); AddRtpReceiverWithSsrcs({7, 8}, remote_video_track_.get());
EXPECT_DEATH(CreateMap(), ""); EXPECT_DEATH(CreateMap(), "");
} }

4
pc/video_rtp_receiver.cc
View File

@ -221,7 +221,7 @@ void VideoRtpReceiver::SetStreams(
} }
} }
if (removed) { if (removed) {
existing_stream->RemoveTrack(track_); existing_stream->RemoveTrack(track_.get());
} }
} }
// Add remote track to any streams that are new. // Add remote track to any streams that are new.
@ -235,7 +235,7 @@ void VideoRtpReceiver::SetStreams(
} }
} }
if (added) { if (added) {
stream->AddTrack(track_); stream->AddTrack(track_.get());
} }
} }
streams_ = streams; streams_ = streams;

14
pc/webrtc_session_description_factory.cc
View File

@ -171,7 +171,7 @@ WebRtcSessionDescriptionFactory::WebRtcSessionDescriptionFactory(
// `SignalCertificateReady`. // `SignalCertificateReady`.
signaling_thread_->Post( signaling_thread_->Post(
RTC_FROM_HERE, this, MSG_USE_CONSTRUCTOR_CERTIFICATE, RTC_FROM_HERE, this, MSG_USE_CONSTRUCTOR_CERTIFICATE,
new rtc::ScopedRefMessageData<rtc::RTCCertificate>(certificate)); new rtc::ScopedRefMessageData<rtc::RTCCertificate>(certificate.get()));
} else { } else {
// Generate certificate. // Generate certificate.
certificate_request_state_ = CERTIFICATE_WAITING; certificate_request_state_ = CERTIFICATE_WAITING;
@ -350,7 +350,7 @@ void WebRtcSessionDescriptionFactory::InternalCreateOffer(
? sdp_info_->local_description()->description() ? sdp_info_->local_description()->description()
: nullptr); : nullptr);
if (!desc) { if (!desc) {
PostCreateSessionDescriptionFailed(request.observer, PostCreateSessionDescriptionFailed(request.observer.get(),
"Failed to initialize the offer."); "Failed to initialize the offer.");
return; return;
} }
@ -377,7 +377,8 @@ void WebRtcSessionDescriptionFactory::InternalCreateOffer(
} }
} }
} }
PostCreateSessionDescriptionSucceeded(request.observer, std::move(offer)); PostCreateSessionDescriptionSucceeded(request.observer.get(),
std::move(offer));
} }
void WebRtcSessionDescriptionFactory::InternalCreateAnswer( void WebRtcSessionDescriptionFactory::InternalCreateAnswer(
@ -411,7 +412,7 @@ void WebRtcSessionDescriptionFactory::InternalCreateAnswer(
? sdp_info_->local_description()->description() ? sdp_info_->local_description()->description()
: nullptr); : nullptr);
if (!desc) { if (!desc) {
PostCreateSessionDescriptionFailed(request.observer, PostCreateSessionDescriptionFailed(request.observer.get(),
"Failed to initialize the answer."); "Failed to initialize the answer.");
return; return;
} }
@ -438,7 +439,8 @@ void WebRtcSessionDescriptionFactory::InternalCreateAnswer(
} }
} }
} }
PostCreateSessionDescriptionSucceeded(request.observer, std::move(answer)); PostCreateSessionDescriptionSucceeded(request.observer.get(),
std::move(answer));
} }
void WebRtcSessionDescriptionFactory::FailPendingRequests( void WebRtcSessionDescriptionFactory::FailPendingRequests(
@ -448,7 +450,7 @@ void WebRtcSessionDescriptionFactory::FailPendingRequests(
const CreateSessionDescriptionRequest& request = const CreateSessionDescriptionRequest& request =
create_session_description_requests_.front(); create_session_description_requests_.front();
PostCreateSessionDescriptionFailed( PostCreateSessionDescriptionFailed(
request.observer, request.observer.get(),
((request.type == CreateSessionDescriptionRequest::kOffer) ((request.type == CreateSessionDescriptionRequest::kOffer)
? "CreateOffer" ? "CreateOffer"
: "CreateAnswer") + : "CreateAnswer") +