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

Change stream.AddTrack/RemoveTrack to take a scoped_refptr argument

Browse Source 
This better reflects the ownership passing of AddTrack, and is more
consistent for RemoveTrack.

Bug: webrtc:13980
Change-Id: Ide5baccf15fc687a4e092f8831ce8c0fea46604e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/259740
Reviewed-by: Niels Moller <nisse@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36603}
This commit is contained in:
Harald Alvestrand 2022-04-21 11:35:43 +00:00 committed by WebRTC LUCI CQ
parent 8088aad5ac
commit 2f7ad28a6d
14 changed files with 145 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
api/media_stream_interface.h
View File

@ -334,11 +334,38 @@ class MediaStreamInterface : public rtc::RefCountInterface,
const std::string& track_id) = 0;
// Takes ownership of added tracks.
// TODO(hta): Should take scoped_refptr rather than raw pointer.
virtual bool AddTrack(AudioTrackInterface* track) = 0;
virtual bool AddTrack(VideoTrackInterface* track) = 0;
virtual bool RemoveTrack(AudioTrackInterface* track) = 0;
virtual bool RemoveTrack(VideoTrackInterface* track) = 0;
// Note: Default implementations are for avoiding link time errors in
// implementations that mock this API.
// TODO(bugs.webrtc.org/13980): Remove default implementations.
virtual bool AddTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
RTC_CHECK_NOTREACHED();
}
virtual bool AddTrack(rtc::scoped_refptr<VideoTrackInterface> track) {
RTC_CHECK_NOTREACHED();
}
virtual bool RemoveTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
RTC_CHECK_NOTREACHED();
}
virtual bool RemoveTrack(rtc::scoped_refptr<VideoTrackInterface> track) {
RTC_CHECK_NOTREACHED();
}
// Deprecated: Should use scoped_refptr versions rather than pointers.
[[deprecated("Pass a scoped_refptr")]] virtual bool AddTrack(
AudioTrackInterface* track) {
return AddTrack(rtc::scoped_refptr<AudioTrackInterface>(track));
}
[[deprecated("Pass a scoped_refptr")]] virtual bool AddTrack(
VideoTrackInterface* track) {
return AddTrack(rtc::scoped_refptr<VideoTrackInterface>(track));
}
[[deprecated("Pass a scoped_refptr")]] virtual bool RemoveTrack(
AudioTrackInterface* track) {
return RemoveTrack(rtc::scoped_refptr<AudioTrackInterface>(track));
}
[[deprecated("Pass a scoped_refptr")]] virtual bool RemoveTrack(
VideoTrackInterface* track) {
return RemoveTrack(rtc::scoped_refptr<VideoTrackInterface>(track));
}
protected:
~MediaStreamInterface() override = default;

4
pc/audio_rtp_receiver.cc
View File

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

19
pc/media_stream.cc
View File

@ -36,21 +36,19 @@ rtc::scoped_refptr<MediaStream> MediaStream::Create(const std::string& id) {
MediaStream::MediaStream(const std::string& id) : id_(id) {}
bool MediaStream::AddTrack(AudioTrackInterface* track) {
return AddTrack<AudioTrackVector, AudioTrackInterface>(
&audio_tracks_, rtc::scoped_refptr<AudioTrackInterface>(track));
bool MediaStream::AddTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
return AddTrack<AudioTrackVector, AudioTrackInterface>(&audio_tracks_, track);
}
bool MediaStream::AddTrack(VideoTrackInterface* track) {
return AddTrack<VideoTrackVector, VideoTrackInterface>(
&video_tracks_, rtc::scoped_refptr<VideoTrackInterface>(track));
bool MediaStream::AddTrack(rtc::scoped_refptr<VideoTrackInterface> track) {
return AddTrack<VideoTrackVector, VideoTrackInterface>(&video_tracks_, track);
}
bool MediaStream::RemoveTrack(AudioTrackInterface* track) {
bool MediaStream::RemoveTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
return RemoveTrack<AudioTrackVector>(&audio_tracks_, track);
}
bool MediaStream::RemoveTrack(VideoTrackInterface* track) {
bool MediaStream::RemoveTrack(rtc::scoped_refptr<VideoTrackInterface> track) {
return RemoveTrack<VideoTrackVector>(&video_tracks_, track);
}
@ -82,8 +80,9 @@ bool MediaStream::AddTrack(TrackVector* tracks,
}
template <typename TrackVector>
bool MediaStream::RemoveTrack(TrackVector* tracks,
MediaStreamTrackInterface* track) {
bool MediaStream::RemoveTrack(
TrackVector* tracks,
rtc::scoped_refptr<MediaStreamTrackInterface> track) {
RTC_DCHECK(tracks != NULL);
if (!track)
return false;

11
pc/media_stream.h
View File

@ -27,10 +27,10 @@ class MediaStream : public Notifier<MediaStreamInterface> {
std::string id() const override { return id_; }
bool AddTrack(AudioTrackInterface* track) override;
bool AddTrack(VideoTrackInterface* track) override;
bool RemoveTrack(AudioTrackInterface* track) override;
bool RemoveTrack(VideoTrackInterface* track) override;
bool AddTrack(rtc::scoped_refptr<AudioTrackInterface> track) override;
bool AddTrack(rtc::scoped_refptr<VideoTrackInterface> track) override;
bool RemoveTrack(rtc::scoped_refptr<AudioTrackInterface> track) override;
bool RemoveTrack(rtc::scoped_refptr<VideoTrackInterface> track) override;
rtc::scoped_refptr<AudioTrackInterface> FindAudioTrack(
const std::string& track_id) override;
rtc::scoped_refptr<VideoTrackInterface> FindVideoTrack(
@ -46,7 +46,8 @@ class MediaStream : public Notifier<MediaStreamInterface> {
template <typename TrackVector, typename Track>
bool AddTrack(TrackVector* Tracks, rtc::scoped_refptr<Track> track);
template <typename TrackVector>
bool RemoveTrack(TrackVector* Tracks, MediaStreamTrackInterface* track);
bool RemoveTrack(TrackVector* Tracks,
rtc::scoped_refptr<MediaStreamTrackInterface> track);
const std::string id_;
AudioTrackVector audio_tracks_;

8
pc/media_stream_proxy.h
View File

@ -31,10 +31,10 @@ PROXY_METHOD1(rtc::scoped_refptr<AudioTrackInterface>,
PROXY_METHOD1(rtc::scoped_refptr<VideoTrackInterface>,
FindVideoTrack,
const std::string&)
PROXY_METHOD1(bool, AddTrack, AudioTrackInterface*)
PROXY_METHOD1(bool, AddTrack, VideoTrackInterface*)
PROXY_METHOD1(bool, RemoveTrack, AudioTrackInterface*)
PROXY_METHOD1(bool, RemoveTrack, VideoTrackInterface*)
PROXY_METHOD1(bool, AddTrack, rtc::scoped_refptr<AudioTrackInterface>)
PROXY_METHOD1(bool, AddTrack, rtc::scoped_refptr<VideoTrackInterface>)
PROXY_METHOD1(bool, RemoveTrack, rtc::scoped_refptr<AudioTrackInterface>)
PROXY_METHOD1(bool, RemoveTrack, rtc::scoped_refptr<VideoTrackInterface>)
PROXY_METHOD1(void, RegisterObserver, ObserverInterface*)
PROXY_METHOD1(void, UnregisterObserver, ObserverInterface*)
END_PROXY_MAP(MediaStream)

20
pc/media_stream_unittest.cc
View File

@ -66,10 +66,10 @@ class MediaStreamTest : public ::testing::Test {
ASSERT_TRUE(audio_track_.get() != NULL);
EXPECT_EQ(MediaStreamTrackInterface::kLive, audio_track_->state());
EXPECT_TRUE(stream_->AddTrack(video_track_.get()));
EXPECT_FALSE(stream_->AddTrack(video_track_.get()));
EXPECT_TRUE(stream_->AddTrack(audio_track_.get()));
EXPECT_FALSE(stream_->AddTrack(audio_track_.get()));
EXPECT_TRUE(stream_->AddTrack(video_track_));
EXPECT_FALSE(stream_->AddTrack(video_track_));
EXPECT_TRUE(stream_->AddTrack(audio_track_));
EXPECT_FALSE(stream_->AddTrack(audio_track_));
}
void ChangeTrack(MediaStreamTrackInterface* track) {
@ -122,19 +122,19 @@ TEST_F(MediaStreamTest, RemoveTrack) {
EXPECT_CALL(observer, OnChanged()).Times(Exactly(2));
EXPECT_TRUE(stream_->RemoveTrack(audio_track_.get()));
EXPECT_FALSE(stream_->RemoveTrack(audio_track_.get()));
EXPECT_TRUE(stream_->RemoveTrack(audio_track_));
EXPECT_FALSE(stream_->RemoveTrack(audio_track_));
EXPECT_EQ(0u, stream_->GetAudioTracks().size());
EXPECT_EQ(0u, stream_->GetAudioTracks().size());
EXPECT_TRUE(stream_->RemoveTrack(video_track_.get()));
EXPECT_FALSE(stream_->RemoveTrack(video_track_.get()));
EXPECT_TRUE(stream_->RemoveTrack(video_track_));
EXPECT_FALSE(stream_->RemoveTrack(video_track_));
EXPECT_EQ(0u, stream_->GetVideoTracks().size());
EXPECT_EQ(0u, stream_->GetVideoTracks().size());
EXPECT_FALSE(stream_->RemoveTrack(static_cast<AudioTrackInterface*>(NULL)));
EXPECT_FALSE(stream_->RemoveTrack(static_cast<VideoTrackInterface*>(NULL)));
EXPECT_FALSE(stream_->RemoveTrack(rtc::scoped_refptr<AudioTrackInterface>()));
EXPECT_FALSE(stream_->RemoveTrack(rtc::scoped_refptr<VideoTrackInterface>()));
}
TEST_F(MediaStreamTest, ChangeVideoTrack) {

42
pc/peer_connection_interface_unittest.cc
View File

@ -549,14 +549,14 @@ rtc::scoped_refptr<StreamCollection> CreateStreamCollection(
rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
webrtc::AudioTrack::Create(kAudioTracks[i * tracks_per_stream + j],
nullptr));
stream->AddTrack(audio_track.get());
stream->AddTrack(audio_track);
// Add a local video track.
rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
webrtc::VideoTrack::Create(kVideoTracks[i * tracks_per_stream + j],
webrtc::FakeVideoTrackSource::Create(),
rtc::Thread::Current()));
stream->AddTrack(video_track.get());
stream->AddTrack(video_track);
}
local_collection->AddStream(stream);
@ -830,7 +830,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
void AddVideoStream(const std::string& label) {
rtc::scoped_refptr<MediaStreamInterface> stream(
pc_factory_->CreateLocalMediaStream(label));
stream->AddTrack(CreateVideoTrack(label + "v0").get());
stream->AddTrack(CreateVideoTrack(label + "v0"));
ASSERT_TRUE(pc_->AddStream(stream.get()));
}
@ -849,7 +849,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
void AddAudioStream(const std::string& label) {
rtc::scoped_refptr<MediaStreamInterface> stream(
pc_factory_->CreateLocalMediaStream(label));
stream->AddTrack(CreateAudioTrack(label + "a0").get());
stream->AddTrack(CreateAudioTrack(label + "a0"));
ASSERT_TRUE(pc_->AddStream(stream.get()));
}
@ -859,8 +859,8 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
// Create a local stream.
rtc::scoped_refptr<MediaStreamInterface> stream(
pc_factory_->CreateLocalMediaStream(stream_id));
stream->AddTrack(CreateAudioTrack(audio_track_label).get());
stream->AddTrack(CreateVideoTrack(video_track_label).get());
stream->AddTrack(CreateAudioTrack(audio_track_label));
stream->AddTrack(CreateVideoTrack(video_track_label));
ASSERT_TRUE(pc_->AddStream(stream.get()));
}
@ -1143,7 +1143,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
MediaStreamInterface* stream) {
rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
webrtc::AudioTrack::Create(track_id, nullptr));
ASSERT_TRUE(stream->AddTrack(audio_track.get()));
ASSERT_TRUE(stream->AddTrack(audio_track));
}
void AddVideoTrack(const std::string& track_id,
@ -1152,7 +1152,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
webrtc::VideoTrack::Create(track_id,
webrtc::FakeVideoTrackSource::Create(),
rtc::Thread::Current()));
ASSERT_TRUE(stream->AddTrack(video_track.get()));
ASSERT_TRUE(stream->AddTrack(video_track));
}
std::unique_ptr<SessionDescriptionInterface> CreateOfferWithOneAudioTrack() {
@ -1463,7 +1463,7 @@ TEST_F(PeerConnectionInterfaceTestPlanB, AddStreams) {
rtc::scoped_refptr<AudioTrackInterface> audio_track(
pc_factory_->CreateAudioTrack(
kStreamId3, static_cast<AudioSourceInterface*>(nullptr)));
stream->AddTrack(audio_track.get());
stream->AddTrack(audio_track);
EXPECT_TRUE(pc_->AddStream(stream.get()));
EXPECT_EQ(3u, pc_->local_streams()->count());
@ -1806,7 +1806,7 @@ TEST_F(PeerConnectionInterfaceTestPlanB, AddTrackAfterAddStream) {
// Add video track to the audio-only stream.
rtc::scoped_refptr<VideoTrackInterface> video_track(
CreateVideoTrack("video_label"));
stream->AddTrack(video_track.get());
stream->AddTrack(video_track);
std::unique_ptr<SessionDescriptionInterface> offer;
ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
@ -1827,7 +1827,7 @@ TEST_F(PeerConnectionInterfaceTestPlanB, RemoveTrackAfterAddStream) {
MediaStreamInterface* stream = pc_->local_streams()->at(0);
// Remove the video track.
stream->RemoveTrack(stream->GetVideoTracks()[0].get());
stream->RemoveTrack(stream->GetVideoTracks()[0]);
std::unique_ptr<SessionDescriptionInterface> offer;
ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
@ -2614,8 +2614,8 @@ TEST_F(PeerConnectionInterfaceTestPlanB, RemoveTrackThenRejectMediaContent) {
CreatePeerConnection(config);
CreateAndSetRemoteOffer(GetSdpStringWithStream1());
MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0].get());
remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0].get());
remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0]);
remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]);
std::unique_ptr<SessionDescriptionInterface> local_answer(
webrtc::CreateSessionDescription(SdpType::kAnswer,
@ -2699,8 +2699,8 @@ TEST_F(PeerConnectionInterfaceTestPlanB, RemoveAlreadyGoneRemoteStream) {
CreatePeerConnection(config);
CreateAndSetRemoteOffer(GetSdpStringWithStream1());
MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0].get());
remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0].get());
remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]);
remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0]);
CreateAndSetRemoteOffer(kSdpStringWithoutStreams);
@ -2969,8 +2969,8 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
// Add a new MediaStream but with the same tracks as in the first stream.
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream_1(
webrtc::MediaStream::Create(kStreams[1]));
stream_1->AddTrack(stream_collection->at(0)->GetVideoTracks()[0].get());
stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0].get());
stream_1->AddTrack(stream_collection->at(0)->GetVideoTracks()[0]);
stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0]);
pc_->AddStream(stream_1.get());
ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
@ -3584,22 +3584,22 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
CreateAudioTrack("audio_track"));
rtc::scoped_refptr<VideoTrackInterface> video_track(
CreateVideoTrack("video_track"));
stream->AddTrack(audio_track.get());
stream->AddTrack(audio_track);
EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
observer_.renegotiation_needed_ = false;
CreateOfferReceiveAnswer();
stream->AddTrack(video_track.get());
stream->AddTrack(video_track);
EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
observer_.renegotiation_needed_ = false;
CreateOfferReceiveAnswer();
stream->RemoveTrack(audio_track.get());
stream->RemoveTrack(audio_track);
EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
observer_.renegotiation_needed_ = false;
CreateOfferReceiveAnswer();
stream->RemoveTrack(video_track.get());
stream->RemoveTrack(video_track);
EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
observer_.renegotiation_needed_ = false;
}

32
pc/rtc_stats_collector_unittest.cc
View File

@ -476,13 +476,15 @@ class RTCStatsCollectorWrapper {
track = CreateFakeTrack(media_type, track_id,
MediaStreamTrackInterface::kLive);
if (add_stream) {
local_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get()));
local_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
static_cast<AudioTrackInterface*>(track.get())));
}
} else {
track = CreateFakeTrack(media_type, track_id,
MediaStreamTrackInterface::kLive);
if (add_stream) {
local_stream->AddTrack(static_cast<VideoTrackInterface*>(track.get()));
local_stream->AddTrack(rtc::scoped_refptr<VideoTrackInterface>(
static_cast<VideoTrackInterface*>(track.get())));
}
}
@ -507,11 +509,13 @@ class RTCStatsCollectorWrapper {
if (media_type == cricket::MEDIA_TYPE_AUDIO) {
track = CreateFakeTrack(media_type, track_id,
MediaStreamTrackInterface::kLive);
remote_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get()));
remote_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
static_cast<AudioTrackInterface*>(track.get())));
} else {
track = CreateFakeTrack(media_type, track_id,
MediaStreamTrackInterface::kLive);
remote_stream->AddTrack(static_cast<VideoTrackInterface*>(track.get()));
remote_stream->AddTrack(rtc::scoped_refptr<VideoTrackInterface>(
static_cast<VideoTrackInterface*>(track.get())));
}
rtc::scoped_refptr<MockRtpReceiverInternal> receiver =
@ -1732,8 +1736,8 @@ TEST_F(RTCStatsCollectorTest,
rtc::scoped_refptr<MediaStreamTrackInterface> local_audio_track =
CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "LocalAudioTrackID",
MediaStreamTrackInterface::kEnded);
local_stream->AddTrack(
static_cast<AudioTrackInterface*>(local_audio_track.get()));
local_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
static_cast<AudioTrackInterface*>(local_audio_track.get())));
cricket::VoiceSenderInfo voice_sender_info_ssrc1;
voice_sender_info_ssrc1.local_stats.push_back(cricket::SsrcSenderInfo());
@ -1788,8 +1792,8 @@ TEST_F(RTCStatsCollectorTest,
rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio_track =
CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "RemoteAudioTrackID",
MediaStreamTrackInterface::kLive);
remote_stream->AddTrack(
static_cast<AudioTrackInterface*>(remote_audio_track.get()));
remote_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
static_cast<AudioTrackInterface*>(remote_audio_track.get())));
cricket::VoiceReceiverInfo voice_receiver_info;
voice_receiver_info.local_stats.push_back(cricket::SsrcReceiverInfo());
@ -1872,8 +1876,8 @@ TEST_F(RTCStatsCollectorTest,
rtc::scoped_refptr<MediaStreamTrackInterface> local_video_track =
CreateFakeTrack(cricket::MEDIA_TYPE_VIDEO, "LocalVideoTrackID",
MediaStreamTrackInterface::kLive);
local_stream->AddTrack(
static_cast<VideoTrackInterface*>(local_video_track.get()));
local_stream->AddTrack(rtc::scoped_refptr<VideoTrackInterface>(
static_cast<VideoTrackInterface*>(local_video_track.get())));
cricket::VideoSenderInfo video_sender_info_ssrc1;
video_sender_info_ssrc1.local_stats.push_back(cricket::SsrcSenderInfo());
@ -1935,8 +1939,8 @@ TEST_F(RTCStatsCollectorTest,
rtc::scoped_refptr<MediaStreamTrackInterface> remote_video_track_ssrc3 =
CreateFakeTrack(cricket::MEDIA_TYPE_VIDEO, "RemoteVideoTrackID3",
MediaStreamTrackInterface::kEnded);
remote_stream->AddTrack(
static_cast<VideoTrackInterface*>(remote_video_track_ssrc3.get()));
remote_stream->AddTrack(rtc::scoped_refptr<VideoTrackInterface>(
static_cast<VideoTrackInterface*>(remote_video_track_ssrc3.get())));
cricket::VideoReceiverInfo video_receiver_info_ssrc3;
video_receiver_info_ssrc3.local_stats.push_back(cricket::SsrcReceiverInfo());
@ -3186,8 +3190,8 @@ TEST_F(RTCStatsCollectorTest, CollectEchoReturnLossFromTrackAudioProcessor) {
CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "LocalAudioTrackID",
MediaStreamTrackInterface::kEnded,
/*create_fake_audio_processor=*/true);
local_stream->AddTrack(
static_cast<AudioTrackInterface*>(local_audio_track.get()));
local_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
static_cast<AudioTrackInterface*>(local_audio_track.get())));
cricket::VoiceSenderInfo voice_sender_info_ssrc1;
voice_sender_info_ssrc1.local_stats.push_back(cricket::SsrcSenderInfo());

6
pc/rtp_sender_receiver_unittest.cc
View File

@ -210,7 +210,7 @@ class RtpSenderReceiverTest
FakeVideoTrackSource::Create(is_screencast));
video_track_ =
VideoTrack::Create(kVideoTrackId, source, rtc::Thread::Current());
EXPECT_TRUE(local_stream_->AddTrack(video_track_.get()));
EXPECT_TRUE(local_stream_->AddTrack(video_track_));
}
void CreateAudioRtpSender() { CreateAudioRtpSender(nullptr); }
@ -218,7 +218,7 @@ class RtpSenderReceiverTest
void CreateAudioRtpSender(
const rtc::scoped_refptr<LocalAudioSource>& source) {
audio_track_ = AudioTrack::Create(kAudioTrackId, source);
EXPECT_TRUE(local_stream_->AddTrack(audio_track_.get()));
EXPECT_TRUE(local_stream_->AddTrack(audio_track_));
std::unique_ptr<MockSetStreamsObserver> set_streams_observer =
std::make_unique<MockSetStreamsObserver>();
audio_rtp_sender_ =
@ -897,7 +897,7 @@ TEST_F(RtpSenderReceiverTest, AudioSenderCanSetParametersBeforeNegotiation) {
TEST_F(RtpSenderReceiverTest, AudioSenderInitParametersMovedAfterNegotiation) {
audio_track_ = AudioTrack::Create(kAudioTrackId, nullptr);
EXPECT_TRUE(local_stream_->AddTrack(audio_track_.get()));
EXPECT_TRUE(local_stream_->AddTrack(audio_track_));
std::unique_ptr<MockSetStreamsObserver> set_streams_observer =
std::make_unique<MockSetStreamsObserver>();

4
pc/rtp_transmission_manager.cc
View File

@ -553,7 +553,7 @@ void RtpTransmissionManager::OnRemoteSenderRemoved(
rtc::scoped_refptr<AudioTrackInterface> audio_track =
stream->FindAudioTrack(sender_info.sender_id);
if (audio_track) {
stream->RemoveTrack(audio_track.get());
stream->RemoveTrack(audio_track);
}
} else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
// Stopping or destroying a VideoRtpReceiver will end the
@ -564,7 +564,7 @@ void RtpTransmissionManager::OnRemoteSenderRemoved(
if (video_track) {
// There's no guarantee the track is still available, e.g. the track may
// have been removed from the stream by an application.
stream->RemoveTrack(video_track.get());
stream->RemoveTrack(video_track);
}
} else {
RTC_DCHECK_NOTREACHED() << "Invalid media type";

47
pc/stats_collector_unittest.cc
View File

@ -774,32 +774,32 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
// stream, which is created if necessary.
void AddOutgoingVideoTrack(FakePeerConnectionForStats* pc,
StatsCollectorForTest* stats) {
track_ = VideoTrack::Create(kLocalTrackId, FakeVideoTrackSource::Create(),
rtc::Thread::Current());
video_track_ = VideoTrack::Create(
kLocalTrackId, FakeVideoTrackSource::Create(), rtc::Thread::Current());
if (GetParam()) {
if (!stream_)
stream_ = MediaStream::Create("streamid");
stream_->AddTrack(track_.get());
stream_->AddTrack(video_track());
stats->AddStream(stream_.get());
} else {
stats->AddTrack(track_.get());
stats->AddTrack(video_track_.get());
}
pc->AddSender(CreateMockSender(track_, kSsrcOfTrack));
pc->AddSender(CreateMockSender(video_track_, kSsrcOfTrack));
}
// Adds a incoming video track with a given SSRC into the stats.
void AddIncomingVideoTrack(FakePeerConnectionForStats* pc,
StatsCollectorForTest* stats) {
track_ = VideoTrack::Create(kRemoteTrackId, FakeVideoTrackSource::Create(),
rtc::Thread::Current());
video_track_ = VideoTrack::Create(
kRemoteTrackId, FakeVideoTrackSource::Create(), rtc::Thread::Current());
if (GetParam()) {
stream_ = MediaStream::Create("streamid");
stream_->AddTrack(track_.get());
stream_->AddTrack(video_track());
stats->AddStream(stream_.get());
} else {
stats->AddTrack(track_.get());
stats->AddTrack(video_track_.get());
}
pc->AddReceiver(CreateMockReceiver(track_, kSsrcOfTrack));
pc->AddReceiver(CreateMockReceiver(video_track_, kSsrcOfTrack));
}
// Adds a outgoing audio track with a given SSRC into the stats,
@ -813,7 +813,7 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
if (GetParam()) {
if (!stream_)
stream_ = MediaStream::Create("streamid");
stream_->AddTrack(audio_track_.get());
stream_->AddTrack(audio_track());
stats->AddStream(stream_.get());
} else {
stats->AddTrack(audio_track_.get());
@ -828,7 +828,7 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
if (GetParam()) {
if (stream_ == nullptr)
stream_ = MediaStream::Create("streamid");
stream_->AddTrack(audio_track_.get());
stream_->AddTrack(audio_track());
stats->AddStream(stream_.get());
} else {
stats->AddTrack(audio_track_.get());
@ -836,8 +836,11 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
pc->AddReceiver(CreateMockReceiver(audio_track_, kSsrcOfTrack));
}
rtc::scoped_refptr<AudioTrackInterface> audio_track() { return audio_track_; }
rtc::scoped_refptr<VideoTrackInterface> video_track() { return video_track_; }
rtc::scoped_refptr<MediaStream> stream_;
rtc::scoped_refptr<VideoTrack> track_;
rtc::scoped_refptr<VideoTrack> video_track_;
rtc::scoped_refptr<FakeAudioTrack> audio_track_;
};
@ -1111,7 +1114,7 @@ TEST_P(StatsCollectorTrackTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
// Get report for the specific `track`.
reports.clear();
stats->GetStats(track_.get(), &reports);
stats->GetStats(video_track_.get(), &reports);
// `reports` should contain at least one session report, one track report,
// and one ssrc report.
EXPECT_LE(3u, reports.size());
@ -1480,7 +1483,7 @@ TEST_P(StatsCollectorTrackTest, FilterOutNegativeInitialValues) {
stream_ = MediaStream::Create("streamid");
auto local_track =
rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kLocalTrackId);
stream_->AddTrack(local_track.get());
stream_->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(local_track.get()));
pc->AddSender(CreateMockSender(local_track, kSsrcOfTrack));
if (GetParam()) {
stats->AddStream(stream_.get());
@ -1490,9 +1493,9 @@ TEST_P(StatsCollectorTrackTest, FilterOutNegativeInitialValues) {
// Create a remote stream with a remote audio track and adds it to the stats.
rtc::scoped_refptr<MediaStream> remote_stream(
MediaStream::Create("remotestreamid"));
auto remote_track =
rtc::scoped_refptr<AudioTrackInterface> remote_track =
rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kRemoteTrackId);
remote_stream->AddTrack(remote_track.get());
remote_stream->AddTrack(remote_track);
pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
if (GetParam()) {
stats->AddStream(remote_stream.get());
@ -1661,9 +1664,10 @@ TEST_P(StatsCollectorTrackTest, LocalAndRemoteTracksWithSameSsrc) {
// Create a remote stream with a remote audio track and adds it to the stats.
rtc::scoped_refptr<MediaStream> remote_stream(
MediaStream::Create("remotestreamid"));
auto remote_track = rtc::make_ref_counted<FakeAudioTrack>(kRemoteTrackId);
rtc::scoped_refptr<AudioTrackInterface> remote_track =
rtc::make_ref_counted<FakeAudioTrack>(kRemoteTrackId);
pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
remote_stream->AddTrack(remote_track.get());
remote_stream->AddTrack(remote_track);
stats->AddStream(remote_stream.get());
VoiceSenderInfo voice_sender_info;
@ -1745,7 +1749,7 @@ TEST_P(StatsCollectorTrackTest, TwoLocalTracksWithSameSsrc) {
VerifyAudioTrackStats(audio_track_.get(), stats.get(), voice_info, &reports);
// Remove the previous audio track from the stream.
stream_->RemoveTrack(audio_track_.get());
stream_->RemoveTrack(audio_track());
stats->RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
pc->RemoveSender(sender);
@ -1753,7 +1757,8 @@ TEST_P(StatsCollectorTrackTest, TwoLocalTracksWithSameSsrc) {
static const std::string kNewTrackId = "new_track_id";
auto new_audio_track = rtc::make_ref_counted<FakeAudioTrack>(kNewTrackId);
pc->AddSender(CreateMockSender(new_audio_track, kSsrcOfTrack));
stream_->AddTrack(new_audio_track.get());
stream_->AddTrack(
rtc::scoped_refptr<AudioTrackInterface>(new_audio_track.get()));
stats->AddLocalAudioTrack(new_audio_track.get(), kSsrcOfTrack);
stats->InvalidateCache();

4
pc/test/peer_connection_test_wrapper.cc
View File

@ -334,7 +334,7 @@ PeerConnectionTestWrapper::GetUserMedia(
rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
peer_connection_factory_->CreateAudioTrack(kAudioTrackLabelBase,
source.get()));
stream->AddTrack(audio_track.get());
stream->AddTrack(audio_track);
}
if (video) {
@ -351,7 +351,7 @@ PeerConnectionTestWrapper::GetUserMedia(
peer_connection_factory_->CreateVideoTrack(videotrack_label,
source.get()));
stream->AddTrack(video_track.get());
stream->AddTrack(video_track);
}
return stream;
}

4
pc/video_rtp_receiver.cc
View File

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

12
sdk/android/src/jni/pc/media_stream.cc
View File

@ -113,7 +113,8 @@ static jboolean JNI_MediaStream_AddAudioTrackToNativeStream(
jlong pointer,
jlong j_audio_track_pointer) {
return reinterpret_cast<MediaStreamInterface*>(pointer)->AddTrack(
reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer));
rtc::scoped_refptr<AudioTrackInterface>(
reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer)));
}
static jboolean JNI_MediaStream_AddVideoTrackToNativeStream(
@ -121,21 +122,24 @@ static jboolean JNI_MediaStream_AddVideoTrackToNativeStream(
jlong pointer,
jlong j_video_track_pointer) {
return reinterpret_cast<MediaStreamInterface*>(pointer)->AddTrack(
reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer));
rtc::scoped_refptr<VideoTrackInterface>(
reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)));
}
static jboolean JNI_MediaStream_RemoveAudioTrack(JNIEnv* jni,
jlong pointer,
jlong j_audio_track_pointer) {
return reinterpret_cast<MediaStreamInterface*>(pointer)->RemoveTrack(
reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer));
rtc::scoped_refptr<AudioTrackInterface>(
reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer)));
}
static jboolean JNI_MediaStream_RemoveVideoTrack(JNIEnv* jni,
jlong pointer,
jlong j_video_track_pointer) {
return reinterpret_cast<MediaStreamInterface*>(pointer)->RemoveTrack(
reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer));
rtc::scoped_refptr<VideoTrackInterface>(
reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)));
}
static ScopedJavaLocalRef<jstring> JNI_MediaStream_GetId(JNIEnv* jni,