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; const std::string& track_id) = 0;
// Takes ownership of added tracks. // Takes ownership of added tracks.
// TODO(hta): Should take scoped_refptr rather than raw pointer. // Note: Default implementations are for avoiding link time errors in
virtual bool AddTrack(AudioTrackInterface* track) = 0; // implementations that mock this API.
virtual bool AddTrack(VideoTrackInterface* track) = 0; // TODO(bugs.webrtc.org/13980): Remove default implementations.
virtual bool RemoveTrack(AudioTrackInterface* track) = 0; virtual bool AddTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
virtual bool RemoveTrack(VideoTrackInterface* track) = 0; 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: protected:
~MediaStreamInterface() override = default; ~MediaStreamInterface() override = default;

4
pc/audio_rtp_receiver.cc
View File

@ -251,7 +251,7 @@ void AudioRtpReceiver::SetStreams(
} }
} }
if (removed) { if (removed) {
existing_stream->RemoveTrack(track_.get()); existing_stream->RemoveTrack(audio_track());
} }
} }
// 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_.get()); stream->AddTrack(audio_track());
} }
} }
streams_ = streams; 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) {} MediaStream::MediaStream(const std::string& id) : id_(id) {}
bool MediaStream::AddTrack(AudioTrackInterface* track) { bool MediaStream::AddTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
return AddTrack<AudioTrackVector, AudioTrackInterface>( return AddTrack<AudioTrackVector, AudioTrackInterface>(&audio_tracks_, track);
&audio_tracks_, rtc::scoped_refptr<AudioTrackInterface>(track));
} }
bool MediaStream::AddTrack(VideoTrackInterface* track) { bool MediaStream::AddTrack(rtc::scoped_refptr<VideoTrackInterface> track) {
return AddTrack<VideoTrackVector, VideoTrackInterface>( return AddTrack<VideoTrackVector, VideoTrackInterface>(&video_tracks_, track);
&video_tracks_, rtc::scoped_refptr<VideoTrackInterface>(track));
} }
bool MediaStream::RemoveTrack(AudioTrackInterface* track) { bool MediaStream::RemoveTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
return RemoveTrack<AudioTrackVector>(&audio_tracks_, 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); return RemoveTrack<VideoTrackVector>(&video_tracks_, track);
} }
@ -82,8 +80,9 @@ bool MediaStream::AddTrack(TrackVector* tracks,
} }
template <typename TrackVector> template <typename TrackVector>
bool MediaStream::RemoveTrack(TrackVector* tracks, bool MediaStream::RemoveTrack(
MediaStreamTrackInterface* track) { TrackVector* tracks,
rtc::scoped_refptr<MediaStreamTrackInterface> track) {
RTC_DCHECK(tracks != NULL); RTC_DCHECK(tracks != NULL);
if (!track) if (!track)
return false; 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_; } std::string id() const override { return id_; }
bool AddTrack(AudioTrackInterface* track) override; bool AddTrack(rtc::scoped_refptr<AudioTrackInterface> track) override;
bool AddTrack(VideoTrackInterface* track) override; bool AddTrack(rtc::scoped_refptr<VideoTrackInterface> track) override;
bool RemoveTrack(AudioTrackInterface* track) override; bool RemoveTrack(rtc::scoped_refptr<AudioTrackInterface> track) override;
bool RemoveTrack(VideoTrackInterface* track) override; bool RemoveTrack(rtc::scoped_refptr<VideoTrackInterface> track) override;
rtc::scoped_refptr<AudioTrackInterface> FindAudioTrack( rtc::scoped_refptr<AudioTrackInterface> FindAudioTrack(
const std::string& track_id) override; const std::string& track_id) override;
rtc::scoped_refptr<VideoTrackInterface> FindVideoTrack( rtc::scoped_refptr<VideoTrackInterface> FindVideoTrack(
@ -46,7 +46,8 @@ class MediaStream : public Notifier<MediaStreamInterface> {
template <typename TrackVector, typename Track> template <typename TrackVector, typename Track>
bool AddTrack(TrackVector* Tracks, rtc::scoped_refptr<Track> track); bool AddTrack(TrackVector* Tracks, rtc::scoped_refptr<Track> track);
template <typename TrackVector> template <typename TrackVector>
bool RemoveTrack(TrackVector* Tracks, MediaStreamTrackInterface* track); bool RemoveTrack(TrackVector* Tracks,
rtc::scoped_refptr<MediaStreamTrackInterface> track);
const std::string id_; const std::string id_;
AudioTrackVector audio_tracks_; 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>, PROXY_METHOD1(rtc::scoped_refptr<VideoTrackInterface>,
FindVideoTrack, FindVideoTrack,
const std::string&) const std::string&)
PROXY_METHOD1(bool, AddTrack, AudioTrackInterface*) PROXY_METHOD1(bool, AddTrack, rtc::scoped_refptr<AudioTrackInterface>)
PROXY_METHOD1(bool, AddTrack, VideoTrackInterface*) PROXY_METHOD1(bool, AddTrack, rtc::scoped_refptr<VideoTrackInterface>)
PROXY_METHOD1(bool, RemoveTrack, AudioTrackInterface*) PROXY_METHOD1(bool, RemoveTrack, rtc::scoped_refptr<AudioTrackInterface>)
PROXY_METHOD1(bool, RemoveTrack, VideoTrackInterface*) PROXY_METHOD1(bool, RemoveTrack, rtc::scoped_refptr<VideoTrackInterface>)
PROXY_METHOD1(void, RegisterObserver, ObserverInterface*) PROXY_METHOD1(void, RegisterObserver, ObserverInterface*)
PROXY_METHOD1(void, UnregisterObserver, ObserverInterface*) PROXY_METHOD1(void, UnregisterObserver, ObserverInterface*)
END_PROXY_MAP(MediaStream) 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); 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_.get())); EXPECT_TRUE(stream_->AddTrack(video_track_));
EXPECT_FALSE(stream_->AddTrack(video_track_.get())); EXPECT_FALSE(stream_->AddTrack(video_track_));
EXPECT_TRUE(stream_->AddTrack(audio_track_.get())); EXPECT_TRUE(stream_->AddTrack(audio_track_));
EXPECT_FALSE(stream_->AddTrack(audio_track_.get())); EXPECT_FALSE(stream_->AddTrack(audio_track_));
} }
void ChangeTrack(MediaStreamTrackInterface* track) { void ChangeTrack(MediaStreamTrackInterface* track) {
@ -122,19 +122,19 @@ TEST_F(MediaStreamTest, RemoveTrack) {
EXPECT_CALL(observer, OnChanged()).Times(Exactly(2)); EXPECT_CALL(observer, OnChanged()).Times(Exactly(2));
EXPECT_TRUE(stream_->RemoveTrack(audio_track_.get())); EXPECT_TRUE(stream_->RemoveTrack(audio_track_));
EXPECT_FALSE(stream_->RemoveTrack(audio_track_.get())); EXPECT_FALSE(stream_->RemoveTrack(audio_track_));
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_.get())); EXPECT_TRUE(stream_->RemoveTrack(video_track_));
EXPECT_FALSE(stream_->RemoveTrack(video_track_.get())); EXPECT_FALSE(stream_->RemoveTrack(video_track_));
EXPECT_EQ(0u, stream_->GetVideoTracks().size()); EXPECT_EQ(0u, stream_->GetVideoTracks().size());
EXPECT_EQ(0u, stream_->GetVideoTracks().size()); EXPECT_EQ(0u, stream_->GetVideoTracks().size());
EXPECT_FALSE(stream_->RemoveTrack(static_cast<AudioTrackInterface*>(NULL))); EXPECT_FALSE(stream_->RemoveTrack(rtc::scoped_refptr<AudioTrackInterface>()));
EXPECT_FALSE(stream_->RemoveTrack(static_cast<VideoTrackInterface*>(NULL))); EXPECT_FALSE(stream_->RemoveTrack(rtc::scoped_refptr<VideoTrackInterface>()));
} }
TEST_F(MediaStreamTest, ChangeVideoTrack) { 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( 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.get()); stream->AddTrack(audio_track);
// 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.get()); stream->AddTrack(video_track);
} }
local_collection->AddStream(stream); local_collection->AddStream(stream);
@ -830,7 +830,7 @@ 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").get()); stream->AddTrack(CreateVideoTrack(label + "v0"));
ASSERT_TRUE(pc_->AddStream(stream.get())); ASSERT_TRUE(pc_->AddStream(stream.get()));
} }
@ -849,7 +849,7 @@ 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").get()); stream->AddTrack(CreateAudioTrack(label + "a0"));
ASSERT_TRUE(pc_->AddStream(stream.get())); ASSERT_TRUE(pc_->AddStream(stream.get()));
} }
@ -859,8 +859,8 @@ 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).get()); stream->AddTrack(CreateAudioTrack(audio_track_label));
stream->AddTrack(CreateVideoTrack(video_track_label).get()); stream->AddTrack(CreateVideoTrack(video_track_label));
ASSERT_TRUE(pc_->AddStream(stream.get())); ASSERT_TRUE(pc_->AddStream(stream.get()));
} }
@ -1143,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.get())); ASSERT_TRUE(stream->AddTrack(audio_track));
} }
void AddVideoTrack(const std::string& track_id, void AddVideoTrack(const std::string& track_id,
@ -1152,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.get())); ASSERT_TRUE(stream->AddTrack(video_track));
} }
std::unique_ptr<SessionDescriptionInterface> CreateOfferWithOneAudioTrack() { std::unique_ptr<SessionDescriptionInterface> CreateOfferWithOneAudioTrack() {
@ -1463,7 +1463,7 @@ TEST_F(PeerConnectionInterfaceTestPlanB, AddStreams) {
rtc::scoped_refptr<AudioTrackInterface> audio_track( rtc::scoped_refptr<AudioTrackInterface> audio_track(
pc_factory_->CreateAudioTrack( pc_factory_->CreateAudioTrack(
kStreamId3, static_cast<AudioSourceInterface*>(nullptr))); kStreamId3, static_cast<AudioSourceInterface*>(nullptr)));
stream->AddTrack(audio_track.get()); stream->AddTrack(audio_track);
EXPECT_TRUE(pc_->AddStream(stream.get())); EXPECT_TRUE(pc_->AddStream(stream.get()));
EXPECT_EQ(3u, pc_->local_streams()->count()); EXPECT_EQ(3u, pc_->local_streams()->count());
@ -1806,7 +1806,7 @@ TEST_F(PeerConnectionInterfaceTestPlanB, AddTrackAfterAddStream) {
// Add video track to the audio-only stream. // Add video track to the audio-only stream.
rtc::scoped_refptr<VideoTrackInterface> video_track( rtc::scoped_refptr<VideoTrackInterface> video_track(
CreateVideoTrack("video_label")); CreateVideoTrack("video_label"));
stream->AddTrack(video_track.get()); stream->AddTrack(video_track);
std::unique_ptr<SessionDescriptionInterface> offer; std::unique_ptr<SessionDescriptionInterface> offer;
ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
@ -1827,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].get()); stream->RemoveTrack(stream->GetVideoTracks()[0]);
std::unique_ptr<SessionDescriptionInterface> offer; std::unique_ptr<SessionDescriptionInterface> offer;
ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
@ -2614,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].get()); remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0]);
remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0].get()); remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]);
std::unique_ptr<SessionDescriptionInterface> local_answer( std::unique_ptr<SessionDescriptionInterface> local_answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, webrtc::CreateSessionDescription(SdpType::kAnswer,
@ -2699,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].get()); remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]);
remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0].get()); remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0]);
CreateAndSetRemoteOffer(kSdpStringWithoutStreams); CreateAndSetRemoteOffer(kSdpStringWithoutStreams);
@ -2969,8 +2969,8 @@ 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].get()); stream_1->AddTrack(stream_collection->at(0)->GetVideoTracks()[0]);
stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0].get()); stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0]);
pc_->AddStream(stream_1.get()); pc_->AddStream(stream_1.get());
ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
@ -3584,22 +3584,22 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
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.get()); stream->AddTrack(audio_track);
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.get()); stream->AddTrack(video_track);
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.get()); stream->RemoveTrack(audio_track);
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.get()); stream->RemoveTrack(video_track);
EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout); EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
observer_.renegotiation_needed_ = false; 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, track = CreateFakeTrack(media_type, track_id,
MediaStreamTrackInterface::kLive); MediaStreamTrackInterface::kLive);
if (add_stream) { if (add_stream) {
local_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get())); local_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
static_cast<AudioTrackInterface*>(track.get())));
} }
} else { } else {
track = CreateFakeTrack(media_type, track_id, track = CreateFakeTrack(media_type, track_id,
MediaStreamTrackInterface::kLive); MediaStreamTrackInterface::kLive);
if (add_stream) { 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) { if (media_type == cricket::MEDIA_TYPE_AUDIO) {
track = CreateFakeTrack(media_type, track_id, track = CreateFakeTrack(media_type, track_id,
MediaStreamTrackInterface::kLive); MediaStreamTrackInterface::kLive);
remote_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get())); remote_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
static_cast<AudioTrackInterface*>(track.get())));
} else { } else {
track = CreateFakeTrack(media_type, track_id, track = CreateFakeTrack(media_type, track_id,
MediaStreamTrackInterface::kLive); 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 = rtc::scoped_refptr<MockRtpReceiverInternal> receiver =
@ -1732,8 +1736,8 @@ TEST_F(RTCStatsCollectorTest,
rtc::scoped_refptr<MediaStreamTrackInterface> local_audio_track = rtc::scoped_refptr<MediaStreamTrackInterface> local_audio_track =
CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "LocalAudioTrackID", CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "LocalAudioTrackID",
MediaStreamTrackInterface::kEnded); MediaStreamTrackInterface::kEnded);
local_stream->AddTrack( local_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
static_cast<AudioTrackInterface*>(local_audio_track.get())); static_cast<AudioTrackInterface*>(local_audio_track.get())));
cricket::VoiceSenderInfo voice_sender_info_ssrc1; cricket::VoiceSenderInfo voice_sender_info_ssrc1;
voice_sender_info_ssrc1.local_stats.push_back(cricket::SsrcSenderInfo()); voice_sender_info_ssrc1.local_stats.push_back(cricket::SsrcSenderInfo());
@ -1788,8 +1792,8 @@ TEST_F(RTCStatsCollectorTest,
rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio_track = rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio_track =
CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "RemoteAudioTrackID", CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "RemoteAudioTrackID",
MediaStreamTrackInterface::kLive); MediaStreamTrackInterface::kLive);
remote_stream->AddTrack( remote_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
static_cast<AudioTrackInterface*>(remote_audio_track.get())); static_cast<AudioTrackInterface*>(remote_audio_track.get())));
cricket::VoiceReceiverInfo voice_receiver_info; cricket::VoiceReceiverInfo voice_receiver_info;
voice_receiver_info.local_stats.push_back(cricket::SsrcReceiverInfo()); voice_receiver_info.local_stats.push_back(cricket::SsrcReceiverInfo());
@ -1872,8 +1876,8 @@ TEST_F(RTCStatsCollectorTest,
rtc::scoped_refptr<MediaStreamTrackInterface> local_video_track = rtc::scoped_refptr<MediaStreamTrackInterface> local_video_track =
CreateFakeTrack(cricket::MEDIA_TYPE_VIDEO, "LocalVideoTrackID", CreateFakeTrack(cricket::MEDIA_TYPE_VIDEO, "LocalVideoTrackID",
MediaStreamTrackInterface::kLive); MediaStreamTrackInterface::kLive);
local_stream->AddTrack( local_stream->AddTrack(rtc::scoped_refptr<VideoTrackInterface>(
static_cast<VideoTrackInterface*>(local_video_track.get())); static_cast<VideoTrackInterface*>(local_video_track.get())));
cricket::VideoSenderInfo video_sender_info_ssrc1; cricket::VideoSenderInfo video_sender_info_ssrc1;
video_sender_info_ssrc1.local_stats.push_back(cricket::SsrcSenderInfo()); 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 = rtc::scoped_refptr<MediaStreamTrackInterface> remote_video_track_ssrc3 =
CreateFakeTrack(cricket::MEDIA_TYPE_VIDEO, "RemoteVideoTrackID3", CreateFakeTrack(cricket::MEDIA_TYPE_VIDEO, "RemoteVideoTrackID3",
MediaStreamTrackInterface::kEnded); MediaStreamTrackInterface::kEnded);
remote_stream->AddTrack( remote_stream->AddTrack(rtc::scoped_refptr<VideoTrackInterface>(
static_cast<VideoTrackInterface*>(remote_video_track_ssrc3.get())); static_cast<VideoTrackInterface*>(remote_video_track_ssrc3.get())));
cricket::VideoReceiverInfo video_receiver_info_ssrc3; cricket::VideoReceiverInfo video_receiver_info_ssrc3;
video_receiver_info_ssrc3.local_stats.push_back(cricket::SsrcReceiverInfo()); video_receiver_info_ssrc3.local_stats.push_back(cricket::SsrcReceiverInfo());
@ -3186,8 +3190,8 @@ TEST_F(RTCStatsCollectorTest, CollectEchoReturnLossFromTrackAudioProcessor) {
CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "LocalAudioTrackID", CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "LocalAudioTrackID",
MediaStreamTrackInterface::kEnded, MediaStreamTrackInterface::kEnded,
/*create_fake_audio_processor=*/true); /*create_fake_audio_processor=*/true);
local_stream->AddTrack( local_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
static_cast<AudioTrackInterface*>(local_audio_track.get())); static_cast<AudioTrackInterface*>(local_audio_track.get())));
cricket::VoiceSenderInfo voice_sender_info_ssrc1; cricket::VoiceSenderInfo voice_sender_info_ssrc1;
voice_sender_info_ssrc1.local_stats.push_back(cricket::SsrcSenderInfo()); 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)); 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_.get())); EXPECT_TRUE(local_stream_->AddTrack(video_track_));
} }
void CreateAudioRtpSender() { CreateAudioRtpSender(nullptr); } void CreateAudioRtpSender() { CreateAudioRtpSender(nullptr); }
@ -218,7 +218,7 @@ 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_.get())); EXPECT_TRUE(local_stream_->AddTrack(audio_track_));
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_ =
@ -897,7 +897,7 @@ 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_.get())); EXPECT_TRUE(local_stream_->AddTrack(audio_track_));
std::unique_ptr<MockSetStreamsObserver> set_streams_observer = std::unique_ptr<MockSetStreamsObserver> set_streams_observer =
std::make_unique<MockSetStreamsObserver>(); 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 = 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.get()); stream->RemoveTrack(audio_track);
} }
} 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.get()); stream->RemoveTrack(video_track);
} }
} else { } else {
RTC_DCHECK_NOTREACHED() << "Invalid media type"; 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. // stream, which is created if necessary.
void AddOutgoingVideoTrack(FakePeerConnectionForStats* pc, void AddOutgoingVideoTrack(FakePeerConnectionForStats* pc,
StatsCollectorForTest* stats) { StatsCollectorForTest* stats) {
track_ = VideoTrack::Create(kLocalTrackId, FakeVideoTrackSource::Create(), video_track_ = VideoTrack::Create(
rtc::Thread::Current()); kLocalTrackId, FakeVideoTrackSource::Create(), rtc::Thread::Current());
if (GetParam()) { if (GetParam()) {
if (!stream_) if (!stream_)
stream_ = MediaStream::Create("streamid"); stream_ = MediaStream::Create("streamid");
stream_->AddTrack(track_.get()); stream_->AddTrack(video_track());
stats->AddStream(stream_.get()); stats->AddStream(stream_.get());
} else { } 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. // Adds a incoming video track with a given SSRC into the stats.
void AddIncomingVideoTrack(FakePeerConnectionForStats* pc, void AddIncomingVideoTrack(FakePeerConnectionForStats* pc,
StatsCollectorForTest* stats) { StatsCollectorForTest* stats) {
track_ = VideoTrack::Create(kRemoteTrackId, FakeVideoTrackSource::Create(), video_track_ = VideoTrack::Create(
rtc::Thread::Current()); kRemoteTrackId, FakeVideoTrackSource::Create(), rtc::Thread::Current());
if (GetParam()) { if (GetParam()) {
stream_ = MediaStream::Create("streamid"); stream_ = MediaStream::Create("streamid");
stream_->AddTrack(track_.get()); stream_->AddTrack(video_track());
stats->AddStream(stream_.get()); stats->AddStream(stream_.get());
} else { } 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, // Adds a outgoing audio track with a given SSRC into the stats,
@ -813,7 +813,7 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
if (GetParam()) { if (GetParam()) {
if (!stream_) if (!stream_)
stream_ = MediaStream::Create("streamid"); stream_ = MediaStream::Create("streamid");
stream_->AddTrack(audio_track_.get()); stream_->AddTrack(audio_track());
stats->AddStream(stream_.get()); stats->AddStream(stream_.get());
} else { } else {
stats->AddTrack(audio_track_.get()); stats->AddTrack(audio_track_.get());
@ -828,7 +828,7 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
if (GetParam()) { if (GetParam()) {
if (stream_ == nullptr) if (stream_ == nullptr)
stream_ = MediaStream::Create("streamid"); stream_ = MediaStream::Create("streamid");
stream_->AddTrack(audio_track_.get()); stream_->AddTrack(audio_track());
stats->AddStream(stream_.get()); stats->AddStream(stream_.get());
} else { } else {
stats->AddTrack(audio_track_.get()); stats->AddTrack(audio_track_.get());
@ -836,8 +836,11 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
pc->AddReceiver(CreateMockReceiver(audio_track_, kSsrcOfTrack)); 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<MediaStream> stream_;
rtc::scoped_refptr<VideoTrack> track_; rtc::scoped_refptr<VideoTrack> video_track_;
rtc::scoped_refptr<FakeAudioTrack> audio_track_; rtc::scoped_refptr<FakeAudioTrack> audio_track_;
}; };
@ -1111,7 +1114,7 @@ TEST_P(StatsCollectorTrackTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
// Get report for the specific `track`. // Get report for the specific `track`.
reports.clear(); reports.clear();
stats->GetStats(track_.get(), &reports); stats->GetStats(video_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());
@ -1480,7 +1483,7 @@ TEST_P(StatsCollectorTrackTest, FilterOutNegativeInitialValues) {
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.get()); stream_->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(local_track.get()));
pc->AddSender(CreateMockSender(local_track, kSsrcOfTrack)); pc->AddSender(CreateMockSender(local_track, kSsrcOfTrack));
if (GetParam()) { if (GetParam()) {
stats->AddStream(stream_.get()); 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. // Create a remote stream with a remote audio track and adds it to the stats.
rtc::scoped_refptr<MediaStream> remote_stream( rtc::scoped_refptr<MediaStream> remote_stream(
MediaStream::Create("remotestreamid")); MediaStream::Create("remotestreamid"));
auto remote_track = rtc::scoped_refptr<AudioTrackInterface> remote_track =
rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kRemoteTrackId); rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kRemoteTrackId);
remote_stream->AddTrack(remote_track.get()); remote_stream->AddTrack(remote_track);
pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack)); pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
if (GetParam()) { if (GetParam()) {
stats->AddStream(remote_stream.get()); 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. // Create a remote stream with a remote audio track and adds it to the stats.
rtc::scoped_refptr<MediaStream> remote_stream( rtc::scoped_refptr<MediaStream> remote_stream(
MediaStream::Create("remotestreamid")); 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)); pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
remote_stream->AddTrack(remote_track.get()); remote_stream->AddTrack(remote_track);
stats->AddStream(remote_stream.get()); stats->AddStream(remote_stream.get());
VoiceSenderInfo voice_sender_info; VoiceSenderInfo voice_sender_info;
@ -1745,7 +1749,7 @@ TEST_P(StatsCollectorTrackTest, TwoLocalTracksWithSameSsrc) {
VerifyAudioTrackStats(audio_track_.get(), 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());
stats->RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack); stats->RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
pc->RemoveSender(sender); pc->RemoveSender(sender);
@ -1753,7 +1757,8 @@ 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.get()); stream_->AddTrack(
rtc::scoped_refptr<AudioTrackInterface>(new_audio_track.get()));
stats->AddLocalAudioTrack(new_audio_track.get(), kSsrcOfTrack); stats->AddLocalAudioTrack(new_audio_track.get(), kSsrcOfTrack);
stats->InvalidateCache(); 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( rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
peer_connection_factory_->CreateAudioTrack(kAudioTrackLabelBase, peer_connection_factory_->CreateAudioTrack(kAudioTrackLabelBase,
source.get())); source.get()));
stream->AddTrack(audio_track.get()); stream->AddTrack(audio_track);
} }
if (video) { if (video) {
@ -351,7 +351,7 @@ PeerConnectionTestWrapper::GetUserMedia(
peer_connection_factory_->CreateVideoTrack(videotrack_label, peer_connection_factory_->CreateVideoTrack(videotrack_label,
source.get())); source.get()));
stream->AddTrack(video_track.get()); stream->AddTrack(video_track);
} }
return stream; return stream;
} }

4
pc/video_rtp_receiver.cc
View File

@ -221,7 +221,7 @@ void VideoRtpReceiver::SetStreams(
} }
} }
if (removed) { if (removed) {
existing_stream->RemoveTrack(track_.get()); existing_stream->RemoveTrack(video_track());
} }
} }
// 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_.get()); stream->AddTrack(video_track());
} }
} }
streams_ = streams; 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 pointer,
jlong j_audio_track_pointer) { jlong j_audio_track_pointer) {
return reinterpret_cast<MediaStreamInterface*>(pointer)->AddTrack( 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( static jboolean JNI_MediaStream_AddVideoTrackToNativeStream(
@ -121,21 +122,24 @@ static jboolean JNI_MediaStream_AddVideoTrackToNativeStream(
jlong pointer, jlong pointer,
jlong j_video_track_pointer) { jlong j_video_track_pointer) {
return reinterpret_cast<MediaStreamInterface*>(pointer)->AddTrack( 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, static jboolean JNI_MediaStream_RemoveAudioTrack(JNIEnv* jni,
jlong pointer, jlong pointer,
jlong j_audio_track_pointer) { jlong j_audio_track_pointer) {
return reinterpret_cast<MediaStreamInterface*>(pointer)->RemoveTrack( 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, static jboolean JNI_MediaStream_RemoveVideoTrack(JNIEnv* jni,
jlong pointer, jlong pointer,
jlong j_video_track_pointer) { jlong j_video_track_pointer) {
return reinterpret_cast<MediaStreamInterface*>(pointer)->RemoveTrack( 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, static ScopedJavaLocalRef<jstring> JNI_MediaStream_GetId(JNIEnv* jni,