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

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

Browse Source 
Bug: webrtc:13464
Change-Id: I729ec2306ec0d6df2e546b5dbb530f57065d60da
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/244090
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#35623}
This commit is contained in:
Niels Möller 2022-01-04 15:20:03 +01:00 committed by WebRTC LUCI CQ
parent de6e1b4ffd
commit e7cc8830ef
19 changed files with 106 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
api/media_stream_interface.h
View File

@ -333,6 +333,8 @@ class MediaStreamInterface : public rtc::RefCountInterface,
virtual rtc::scoped_refptr<VideoTrackInterface> FindVideoTrack( virtual rtc::scoped_refptr<VideoTrackInterface> FindVideoTrack(
const std::string& track_id) = 0; 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(AudioTrackInterface* track) = 0;
virtual bool AddTrack(VideoTrackInterface* track) = 0; virtual bool AddTrack(VideoTrackInterface* track) = 0;
virtual bool RemoveTrack(AudioTrackInterface* track) = 0; virtual bool RemoveTrack(AudioTrackInterface* track) = 0;

3
pc/connection_context.cc
View File

@ -75,7 +75,8 @@ std::unique_ptr<SctpTransportFactoryInterface> MaybeCreateSctpFactory(
// Static // Static
rtc::scoped_refptr<ConnectionContext> ConnectionContext::Create( rtc::scoped_refptr<ConnectionContext> ConnectionContext::Create(
PeerConnectionFactoryDependencies* dependencies) { PeerConnectionFactoryDependencies* dependencies) {
return new ConnectionContext(dependencies); return rtc::scoped_refptr<ConnectionContext>(
new ConnectionContext(dependencies));
} }
ConnectionContext::ConnectionContext( ConnectionContext::ConnectionContext(

12
pc/media_stream.cc
View File

@ -12,6 +12,7 @@
#include <stddef.h> #include <stddef.h>
#include <utility>
#include <vector> #include <vector>
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
@ -41,11 +42,13 @@ bool MediaStream::AddTrack(AudioTrackInterface* track) {
} }
bool MediaStream::AddTrack(VideoTrackInterface* track) { bool MediaStream::AddTrack(VideoTrackInterface* track) {
return AddTrack<VideoTrackVector, VideoTrackInterface>(&video_tracks_, track); return AddTrack<VideoTrackVector, VideoTrackInterface>(
&video_tracks_, rtc::scoped_refptr<VideoTrackInterface>(track));
} }
bool MediaStream::RemoveTrack(AudioTrackInterface* track) { bool MediaStream::RemoveTrack(AudioTrackInterface* track) {
return RemoveTrack<AudioTrackVector>(&audio_tracks_, track); return RemoveTrack<AudioTrackVector>(
&audio_tracks_, rtc::scoped_refptr<AudioTrackInterface>(track));
} }
bool MediaStream::RemoveTrack(VideoTrackInterface* track) { bool MediaStream::RemoveTrack(VideoTrackInterface* track) {
@ -69,11 +72,12 @@ rtc::scoped_refptr<VideoTrackInterface> MediaStream::FindVideoTrack(
} }
template <typename TrackVector, typename Track> template <typename TrackVector, typename Track>
bool MediaStream::AddTrack(TrackVector* tracks, Track* track) { bool MediaStream::AddTrack(TrackVector* tracks,
rtc::scoped_refptr<Track> track) {
typename TrackVector::iterator it = FindTrack(tracks, track->id()); typename TrackVector::iterator it = FindTrack(tracks, track->id());
if (it != tracks->end()) if (it != tracks->end())
return false; return false;
tracks->push_back(track); tracks->emplace_back(std::move((track)));
FireOnChanged(); FireOnChanged();
return true; return true;
} }

2
pc/media_stream.h
View File

@ -44,7 +44,7 @@ class MediaStream : public Notifier<MediaStreamInterface> {
private: private:
template <typename TrackVector, typename Track> template <typename TrackVector, typename Track>
bool AddTrack(TrackVector* Tracks, 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, MediaStreamTrackInterface* track);

5
pc/peer_connection.cc
View File

@ -849,7 +849,7 @@ RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::AddTrack(
bool PeerConnection::RemoveTrack(RtpSenderInterface* sender) { bool PeerConnection::RemoveTrack(RtpSenderInterface* sender) {
TRACE_EVENT0("webrtc", "PeerConnection::RemoveTrack"); TRACE_EVENT0("webrtc", "PeerConnection::RemoveTrack");
return RemoveTrackNew(sender).ok(); return RemoveTrackNew(rtc::scoped_refptr<RtpSenderInterface>(sender)).ok();
} }
RTCError PeerConnection::RemoveTrackNew( RTCError PeerConnection::RemoveTrackNew(
@ -1181,7 +1181,8 @@ void PeerConnection::GetStats(RTCStatsCollectorCallback* callback) {
RTC_DCHECK(stats_collector_); RTC_DCHECK(stats_collector_);
RTC_DCHECK(callback); RTC_DCHECK(callback);
RTC_LOG_THREAD_BLOCK_COUNT(); RTC_LOG_THREAD_BLOCK_COUNT();
stats_collector_->GetStatsReport(callback); stats_collector_->GetStatsReport(
rtc::scoped_refptr<RTCStatsCollectorCallback>(callback));
} }
void PeerConnection::GetStats( void PeerConnection::GetStats(

32
pc/peer_connection_end_to_end_unittest.cc
View File

@ -60,9 +60,9 @@ class PeerConnectionEndToEndBaseTest : public sigslot::has_slots<>,
worker_thread_(rtc::Thread::Create()) { worker_thread_(rtc::Thread::Create()) {
RTC_CHECK(network_thread_->Start()); RTC_CHECK(network_thread_->Start());
RTC_CHECK(worker_thread_->Start()); RTC_CHECK(worker_thread_->Start());
caller_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>( caller_ = rtc::make_ref_counted<PeerConnectionTestWrapper>(
"caller", network_thread_.get(), worker_thread_.get()); "caller", network_thread_.get(), worker_thread_.get());
callee_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>( callee_ = rtc::make_ref_counted<PeerConnectionTestWrapper>(
"callee", network_thread_.get(), worker_thread_.get()); "callee", network_thread_.get(), worker_thread_.get());
webrtc::PeerConnectionInterface::IceServer ice_server; webrtc::PeerConnectionInterface::IceServer ice_server;
ice_server.uri = "stun:stun.l.google.com:19302"; ice_server.uri = "stun:stun.l.google.com:19302";
@ -126,11 +126,13 @@ class PeerConnectionEndToEndBaseTest : public sigslot::has_slots<>,
} }
void OnCallerAddedDataChanel(DataChannelInterface* dc) { void OnCallerAddedDataChanel(DataChannelInterface* dc) {
caller_signaled_data_channels_.push_back(dc); caller_signaled_data_channels_.push_back(
rtc::scoped_refptr<DataChannelInterface>(dc));
} }
void OnCalleeAddedDataChannel(DataChannelInterface* dc) { void OnCalleeAddedDataChannel(DataChannelInterface* dc) {
callee_signaled_data_channels_.push_back(dc); callee_signaled_data_channels_.push_back(
rtc::scoped_refptr<DataChannelInterface>(dc));
} }
// Tests that `dc1` and `dc2` can send to and receive from each other. // Tests that `dc1` and `dc2` can send to and receive from each other.
@ -258,7 +260,7 @@ rtc::scoped_refptr<webrtc::AudioDecoderFactory>
CreateForwardingMockDecoderFactory( CreateForwardingMockDecoderFactory(
webrtc::AudioDecoderFactory* real_decoder_factory) { webrtc::AudioDecoderFactory* real_decoder_factory) {
rtc::scoped_refptr<webrtc::MockAudioDecoderFactory> mock_decoder_factory = rtc::scoped_refptr<webrtc::MockAudioDecoderFactory> mock_decoder_factory =
new rtc::RefCountedObject<StrictMock<webrtc::MockAudioDecoderFactory>>; rtc::make_ref_counted<StrictMock<webrtc::MockAudioDecoderFactory>>();
EXPECT_CALL(*mock_decoder_factory, GetSupportedDecoders()) EXPECT_CALL(*mock_decoder_factory, GetSupportedDecoders())
.Times(AtLeast(1)) .Times(AtLeast(1))
.WillRepeatedly(Invoke([real_decoder_factory] { .WillRepeatedly(Invoke([real_decoder_factory] {
@ -432,26 +434,22 @@ TEST_P(PeerConnectionEndToEndTest, CallWithCustomCodec) {
std::vector<webrtc::AudioCodecPairId> encoder_id1, encoder_id2, decoder_id1, std::vector<webrtc::AudioCodecPairId> encoder_id1, encoder_id2, decoder_id1,
decoder_id2; decoder_id2;
CreatePcs(rtc::scoped_refptr<webrtc::AudioEncoderFactory>( CreatePcs(rtc::make_ref_counted<IdLoggingAudioEncoderFactory>(
new rtc::RefCountedObject<IdLoggingAudioEncoderFactory>(
webrtc::CreateAudioEncoderFactory< webrtc::CreateAudioEncoderFactory<
AudioEncoderUnicornSparklesRainbow>(), AudioEncoderUnicornSparklesRainbow>(),
&encoder_id1)), &encoder_id1),
rtc::scoped_refptr<webrtc::AudioDecoderFactory>( rtc::make_ref_counted<IdLoggingAudioDecoderFactory>(
new rtc::RefCountedObject<IdLoggingAudioDecoderFactory>(
webrtc::CreateAudioDecoderFactory< webrtc::CreateAudioDecoderFactory<
AudioDecoderUnicornSparklesRainbow>(), AudioDecoderUnicornSparklesRainbow>(),
&decoder_id1)), &decoder_id1),
rtc::scoped_refptr<webrtc::AudioEncoderFactory>( rtc::make_ref_counted<IdLoggingAudioEncoderFactory>(
new rtc::RefCountedObject<IdLoggingAudioEncoderFactory>(
webrtc::CreateAudioEncoderFactory< webrtc::CreateAudioEncoderFactory<
AudioEncoderUnicornSparklesRainbow>(), AudioEncoderUnicornSparklesRainbow>(),
&encoder_id2)), &encoder_id2),
rtc::scoped_refptr<webrtc::AudioDecoderFactory>( rtc::make_ref_counted<IdLoggingAudioDecoderFactory>(
new rtc::RefCountedObject<IdLoggingAudioDecoderFactory>(
webrtc::CreateAudioDecoderFactory< webrtc::CreateAudioDecoderFactory<
AudioDecoderUnicornSparklesRainbow>(), AudioDecoderUnicornSparklesRainbow>(),
&decoder_id2))); &decoder_id2));
GetAndAddUserMedia(); GetAndAddUserMedia();
Negotiate(); Negotiate();
WaitForCallEstablished(); WaitForCallEstablished();

3
pc/peer_connection_factory.cc
View File

@ -284,7 +284,8 @@ rtc::scoped_refptr<AudioTrackInterface> PeerConnectionFactory::CreateAudioTrack(
const std::string& id, const std::string& id,
AudioSourceInterface* source) { AudioSourceInterface* source) {
RTC_DCHECK(signaling_thread()->IsCurrent()); RTC_DCHECK(signaling_thread()->IsCurrent());
rtc::scoped_refptr<AudioTrackInterface> track(AudioTrack::Create(id, source)); rtc::scoped_refptr<AudioTrackInterface> track(
AudioTrack::Create(id, rtc::scoped_refptr<AudioSourceInterface>(source)));
return AudioTrackProxy::Create(signaling_thread(), track); return AudioTrackProxy::Create(signaling_thread(), track);
} }

4
pc/peer_connection_interface_unittest.cc
View File

@ -2456,8 +2456,8 @@ TEST_F(PeerConnectionInterfaceTestPlanB, CloseAndTestMethods) {
CreateAnswerAsLocalDescription(); CreateAnswerAsLocalDescription();
ASSERT_EQ(1u, pc_->local_streams()->count()); ASSERT_EQ(1u, pc_->local_streams()->count());
rtc::scoped_refptr<MediaStreamInterface> local_stream = rtc::scoped_refptr<MediaStreamInterface> local_stream(
pc_->local_streams()->at(0); pc_->local_streams()->at(0));
pc_->Close(); pc_->Close();

6
pc/peer_connection_rtp_unittest.cc
View File

@ -738,10 +738,12 @@ TEST_F(PeerConnectionRtpTestPlanB,
// when the first callback is invoked. // when the first callback is invoked.
callee->pc()->SetRemoteDescription( callee->pc()->SetRemoteDescription(
std::move(srd1_sdp), std::move(srd1_sdp),
new OnSuccessObserver<decltype(srd1_callback)>(srd1_callback)); rtc::make_ref_counted<OnSuccessObserver<decltype(srd1_callback)>>(
srd1_callback));
callee->pc()->SetRemoteDescription( callee->pc()->SetRemoteDescription(
std::move(srd2_sdp), std::move(srd2_sdp),
new OnSuccessObserver<decltype(srd2_callback)>(srd2_callback)); rtc::make_ref_counted<OnSuccessObserver<decltype(srd2_callback)>>(
srd2_callback));
EXPECT_TRUE_WAIT(srd1_callback_called, kDefaultTimeout); EXPECT_TRUE_WAIT(srd1_callback_called, kDefaultTimeout);
EXPECT_TRUE_WAIT(srd2_callback_called, kDefaultTimeout); EXPECT_TRUE_WAIT(srd2_callback_called, kDefaultTimeout);
} }

15
pc/peer_connection_signaling_unittest.cc
View File

@ -674,8 +674,9 @@ TEST_P(PeerConnectionSignalingTest, SetRemoteDescriptionExecutesImmediately) {
// By not waiting for the observer's callback we can verify that the operation // By not waiting for the observer's callback we can verify that the operation
// executed immediately. // executed immediately.
callee->pc()->SetRemoteDescription(std::move(offer), callee->pc()->SetRemoteDescription(
new FakeSetRemoteDescriptionObserver()); std::move(offer),
rtc::make_ref_counted<FakeSetRemoteDescriptionObserver>());
EXPECT_EQ(2u, callee->pc()->GetReceivers().size()); EXPECT_EQ(2u, callee->pc()->GetReceivers().size());
} }
@ -693,8 +694,9 @@ TEST_P(PeerConnectionSignalingTest, CreateOfferBlocksSetRemoteDescription) {
// 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, RTCOfferAnswerOptions());
callee->pc()->SetRemoteDescription(std::move(offer), callee->pc()->SetRemoteDescription(
new FakeSetRemoteDescriptionObserver()); std::move(offer),
rtc::make_ref_counted<FakeSetRemoteDescriptionObserver>());
// CreateOffer() is asynchronous; without message processing this operation // CreateOffer() is asynchronous; without message processing this operation
// should not have completed. // should not have completed.
EXPECT_FALSE(offer_observer->called()); EXPECT_FALSE(offer_observer->called());
@ -1113,8 +1115,9 @@ TEST_F(PeerConnectionSignalingUnifiedPlanTest,
// the new observer should also be invoked synchronously - as is ensured by // the new observer should also be invoked synchronously - as is ensured by
// other tests.) // other tests.)
RTC_DCHECK(!caller->pc()->GetTransceivers()[0]->mid().has_value()); RTC_DCHECK(!caller->pc()->GetTransceivers()[0]->mid().has_value());
caller->pc()->SetLocalDescription(std::move(offer), caller->pc()->SetLocalDescription(
new FakeSetLocalDescriptionObserver()); std::move(offer),
rtc::make_ref_counted<FakeSetLocalDescriptionObserver>());
EXPECT_TRUE(caller->pc()->GetTransceivers()[0]->mid().has_value()); EXPECT_TRUE(caller->pc()->GetTransceivers()[0]->mid().has_value());
} }

3
pc/peer_connection_wrapper.cc
View File

@ -168,8 +168,7 @@ bool PeerConnectionWrapper::SetRemoteDescription(
bool PeerConnectionWrapper::SetRemoteDescription( bool PeerConnectionWrapper::SetRemoteDescription(
std::unique_ptr<SessionDescriptionInterface> desc, std::unique_ptr<SessionDescriptionInterface> desc,
RTCError* error_out) { RTCError* error_out) {
rtc::scoped_refptr<FakeSetRemoteDescriptionObserver> observer = auto observer = rtc::make_ref_counted<FakeSetRemoteDescriptionObserver>();
new FakeSetRemoteDescriptionObserver();
pc()->SetRemoteDescription(std::move(desc), observer); pc()->SetRemoteDescription(std::move(desc), observer);
EXPECT_EQ_WAIT(true, observer->called(), kDefaultTimeout); EXPECT_EQ_WAIT(true, observer->called(), kDefaultTimeout);
bool ok = observer->error().ok(); bool ok = observer->error().ok();

15
pc/rtc_stats_collector.cc
View File

@ -1224,7 +1224,8 @@ void RTCStatsCollector::GetStatsReportInternal(
std::vector<RequestInfo> requests_; std::vector<RequestInfo> requests_;
}; };
signaling_thread_->PostTask(std::make_unique<DeliveryTask>( signaling_thread_->PostTask(std::make_unique<DeliveryTask>(
this, cached_report_, std::move(requests))); rtc::scoped_refptr<RTCStatsCollector>(this), cached_report_,
std::move(requests)));
} else if (!num_pending_partial_reports_) { } else if (!num_pending_partial_reports_) {
// Only start gathering stats if we're not already gathering stats. In the // Only start gathering stats if we're not already gathering stats. In the
// case of already gathering stats, `callback_` will be invoked when there // case of already gathering stats, `callback_` will be invoked when there
@ -1660,14 +1661,16 @@ void RTCStatsCollector::ProduceMediaStreamTrackStats_s(
for (const RtpTransceiverStatsInfo& stats : transceiver_stats_infos_) { for (const RtpTransceiverStatsInfo& stats : transceiver_stats_infos_) {
std::vector<rtc::scoped_refptr<RtpSenderInternal>> senders; std::vector<rtc::scoped_refptr<RtpSenderInternal>> senders;
for (const auto& sender : stats.transceiver->senders()) { for (const auto& sender : stats.transceiver->senders()) {
senders.push_back(sender->internal()); senders.push_back(
rtc::scoped_refptr<RtpSenderInternal>(sender->internal()));
} }
ProduceSenderMediaTrackStats(timestamp_us, *stats.track_media_info_map, ProduceSenderMediaTrackStats(timestamp_us, *stats.track_media_info_map,
senders, report); senders, report);
std::vector<rtc::scoped_refptr<RtpReceiverInternal>> receivers; std::vector<rtc::scoped_refptr<RtpReceiverInternal>> receivers;
for (const auto& receiver : stats.transceiver->receivers()) { for (const auto& receiver : stats.transceiver->receivers()) {
receivers.push_back(receiver->internal()); receivers.push_back(
rtc::scoped_refptr<RtpReceiverInternal>(receiver->internal()));
} }
ProduceReceiverMediaTrackStats(timestamp_us, *stats.track_media_info_map, ProduceReceiverMediaTrackStats(timestamp_us, *stats.track_media_info_map,
receivers, report); receivers, report);
@ -2210,11 +2213,13 @@ void RTCStatsCollector::PrepareTransceiverStatsInfosAndCallStats_s_w_n() {
} }
std::vector<rtc::scoped_refptr<RtpSenderInternal>> senders; std::vector<rtc::scoped_refptr<RtpSenderInternal>> senders;
for (const auto& sender : transceiver->senders()) { for (const auto& sender : transceiver->senders()) {
senders.push_back(sender->internal()); senders.push_back(
rtc::scoped_refptr<RtpSenderInternal>(sender->internal()));
} }
std::vector<rtc::scoped_refptr<RtpReceiverInternal>> receivers; std::vector<rtc::scoped_refptr<RtpReceiverInternal>> receivers;
for (const auto& receiver : transceiver->receivers()) { for (const auto& receiver : transceiver->receivers()) {
receivers.push_back(receiver->internal()); receivers.push_back(
rtc::scoped_refptr<RtpReceiverInternal>(receiver->internal()));
} }
stats.track_media_info_map = std::make_unique<TrackMediaInfoMap>( stats.track_media_info_map = std::make_unique<TrackMediaInfoMap>(
std::move(voice_media_info), std::move(video_media_info), senders, std::move(voice_media_info), std::move(video_media_info), senders,

29
pc/rtc_stats_collector_unittest.cc
View File

@ -1152,10 +1152,10 @@ TEST_F(RTCStatsCollectorTest, CollectRTCCertificateStatsChain) {
} }
TEST_F(RTCStatsCollectorTest, CollectTwoRTCDataChannelStatsWithPendingId) { TEST_F(RTCStatsCollectorTest, CollectTwoRTCDataChannelStatsWithPendingId) {
pc_->AddSctpDataChannel( pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
new MockSctpDataChannel(/*id=*/-1, DataChannelInterface::kConnecting)); /*id=*/-1, DataChannelInterface::kConnecting));
pc_->AddSctpDataChannel( pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
new MockSctpDataChannel(/*id=*/-1, DataChannelInterface::kConnecting)); /*id=*/-1, DataChannelInterface::kConnecting));
rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport(); rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
} }
@ -1165,7 +1165,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
// This is not a safe assumption, but in order to make it work for // This is not a safe assumption, but in order to make it work for
// the test, we reset the ID allocator at test start. // the test, we reset the ID allocator at test start.
SctpDataChannel::ResetInternalIdAllocatorForTesting(-1); SctpDataChannel::ResetInternalIdAllocatorForTesting(-1);
pc_->AddSctpDataChannel(new MockSctpDataChannel( pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
0, "MockSctpDataChannel0", DataChannelInterface::kConnecting, "udp", 1, 2, 0, "MockSctpDataChannel0", DataChannelInterface::kConnecting, "udp", 1, 2,
3, 4)); 3, 4));
RTCDataChannelStats expected_data_channel0("RTCDataChannel_0", 0); RTCDataChannelStats expected_data_channel0("RTCDataChannel_0", 0);
@ -1178,9 +1178,9 @@ TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
expected_data_channel0.messages_received = 3; expected_data_channel0.messages_received = 3;
expected_data_channel0.bytes_received = 4; expected_data_channel0.bytes_received = 4;
pc_->AddSctpDataChannel(new MockSctpDataChannel(1, "MockSctpDataChannel1", pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
DataChannelInterface::kOpen, 1, "MockSctpDataChannel1", DataChannelInterface::kOpen, "tcp", 5, 6, 7,
"tcp", 5, 6, 7, 8)); 8));
RTCDataChannelStats expected_data_channel1("RTCDataChannel_1", 0); RTCDataChannelStats expected_data_channel1("RTCDataChannel_1", 0);
expected_data_channel1.label = "MockSctpDataChannel1"; expected_data_channel1.label = "MockSctpDataChannel1";
expected_data_channel1.protocol = "tcp"; expected_data_channel1.protocol = "tcp";
@ -1191,7 +1191,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
expected_data_channel1.messages_received = 7; expected_data_channel1.messages_received = 7;
expected_data_channel1.bytes_received = 8; expected_data_channel1.bytes_received = 8;
pc_->AddSctpDataChannel(new MockSctpDataChannel( pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
2, "MockSctpDataChannel2", DataChannelInterface::kClosing, "udp", 9, 10, 2, "MockSctpDataChannel2", DataChannelInterface::kClosing, "udp", 9, 10,
11, 12)); 11, 12));
RTCDataChannelStats expected_data_channel2("RTCDataChannel_2", 0); RTCDataChannelStats expected_data_channel2("RTCDataChannel_2", 0);
@ -1204,9 +1204,9 @@ TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
expected_data_channel2.messages_received = 11; expected_data_channel2.messages_received = 11;
expected_data_channel2.bytes_received = 12; expected_data_channel2.bytes_received = 12;
pc_->AddSctpDataChannel(new MockSctpDataChannel(3, "MockSctpDataChannel3", pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
DataChannelInterface::kClosed, 3, "MockSctpDataChannel3", DataChannelInterface::kClosed, "tcp", 13, 14,
"tcp", 13, 14, 15, 16)); 15, 16));
RTCDataChannelStats expected_data_channel3("RTCDataChannel_3", 0); RTCDataChannelStats expected_data_channel3("RTCDataChannel_3", 0);
expected_data_channel3.label = "MockSctpDataChannel3"; expected_data_channel3.label = "MockSctpDataChannel3";
expected_data_channel3.protocol = "tcp"; expected_data_channel3.protocol = "tcp";
@ -3358,8 +3358,9 @@ class FakeRTCStatsCollector : public RTCStatsCollector,
static rtc::scoped_refptr<FakeRTCStatsCollector> Create( static rtc::scoped_refptr<FakeRTCStatsCollector> Create(
PeerConnectionInternal* pc, PeerConnectionInternal* pc,
int64_t cache_lifetime_us) { int64_t cache_lifetime_us) {
return new rtc::RefCountedObject<FakeRTCStatsCollector>(pc, return rtc::scoped_refptr<FakeRTCStatsCollector>(
cache_lifetime_us); new rtc::RefCountedObject<FakeRTCStatsCollector>(pc,
cache_lifetime_us));
} }
// Since FakeRTCStatsCollector inherits twice from RefCountInterface, once via // Since FakeRTCStatsCollector inherits twice from RefCountInterface, once via

2
pc/rtp_sender_receiver_unittest.cc
View File

@ -577,7 +577,7 @@ TEST_F(RtpSenderReceiverTest, LocalAudioSourceOptionsApplied) {
cricket::AudioOptions options; cricket::AudioOptions options;
options.echo_cancellation = true; options.echo_cancellation = true;
auto source = LocalAudioSource::Create(&options); auto source = LocalAudioSource::Create(&options);
CreateAudioRtpSender(source.get()); CreateAudioRtpSender(source);
EXPECT_EQ(true, voice_media_channel_->options().echo_cancellation); EXPECT_EQ(true, voice_media_channel_->options().echo_cancellation);

4
pc/rtp_transceiver.cc
View File

@ -273,14 +273,14 @@ bool RtpTransceiver::RemoveReceiver(RtpReceiverInterface* receiver) {
rtc::scoped_refptr<RtpSenderInternal> RtpTransceiver::sender_internal() const { rtc::scoped_refptr<RtpSenderInternal> RtpTransceiver::sender_internal() const {
RTC_DCHECK(unified_plan_); RTC_DCHECK(unified_plan_);
RTC_CHECK_EQ(1u, senders_.size()); RTC_CHECK_EQ(1u, senders_.size());
return senders_[0]->internal(); return rtc::scoped_refptr<RtpSenderInternal>(senders_[0]->internal());
} }
rtc::scoped_refptr<RtpReceiverInternal> RtpTransceiver::receiver_internal() rtc::scoped_refptr<RtpReceiverInternal> RtpTransceiver::receiver_internal()
const { const {
RTC_DCHECK(unified_plan_); RTC_DCHECK(unified_plan_);
RTC_CHECK_EQ(1u, receivers_.size()); RTC_CHECK_EQ(1u, receivers_.size());
return receivers_[0]->internal(); return rtc::scoped_refptr<RtpReceiverInternal>(receivers_[0]->internal());
} }
cricket::MediaType RtpTransceiver::media_type() const { cricket::MediaType RtpTransceiver::media_type() const {

6
pc/rtp_transmission_manager.cc
View File

@ -378,7 +378,8 @@ void RtpTransmissionManager::AddAudioTrack(AudioTrackInterface* track,
} }
// Normal case; we've never seen this track before. // Normal case; we've never seen this track before.
auto new_sender = CreateSender(cricket::MEDIA_TYPE_AUDIO, track->id(), track, auto new_sender = CreateSender(cricket::MEDIA_TYPE_AUDIO, track->id(),
rtc::scoped_refptr<AudioTrackInterface>(track),
{stream->id()}, {}); {stream->id()}, {});
new_sender->internal()->SetMediaChannel(voice_media_channel()); new_sender->internal()->SetMediaChannel(voice_media_channel());
GetAudioTransceiver()->internal()->AddSender(new_sender); GetAudioTransceiver()->internal()->AddSender(new_sender);
@ -424,7 +425,8 @@ void RtpTransmissionManager::AddVideoTrack(VideoTrackInterface* track,
} }
// Normal case; we've never seen this track before. // Normal case; we've never seen this track before.
auto new_sender = CreateSender(cricket::MEDIA_TYPE_VIDEO, track->id(), track, auto new_sender = CreateSender(cricket::MEDIA_TYPE_VIDEO, track->id(),
rtc::scoped_refptr<VideoTrackInterface>(track),
{stream->id()}, {}); {stream->id()}, {});
new_sender->internal()->SetMediaChannel(video_media_channel()); new_sender->internal()->SetMediaChannel(video_media_channel());
GetVideoTransceiver()->internal()->AddSender(new_sender); GetVideoTransceiver()->internal()->AddSender(new_sender);

21
pc/sdp_offer_answer.cc
View File

@ -1192,7 +1192,8 @@ void SdpOfferAnswerHandler::SetLocalDescription(
RTC_DCHECK_RUN_ON(signaling_thread()); RTC_DCHECK_RUN_ON(signaling_thread());
SetLocalDescription( SetLocalDescription(
rtc::make_ref_counted<SetSessionDescriptionObserverAdapter>( rtc::make_ref_counted<SetSessionDescriptionObserverAdapter>(
weak_ptr_factory_.GetWeakPtr(), observer)); weak_ptr_factory_.GetWeakPtr(),
rtc::scoped_refptr<SetSessionDescriptionObserver>(observer)));
} }
void SdpOfferAnswerHandler::SetLocalDescription( void SdpOfferAnswerHandler::SetLocalDescription(
@ -2238,8 +2239,8 @@ void SdpOfferAnswerHandler::SetAssociatedRemoteStreams(
RTC_DCHECK_RUN_ON(signaling_thread()); RTC_DCHECK_RUN_ON(signaling_thread());
std::vector<rtc::scoped_refptr<MediaStreamInterface>> media_streams; std::vector<rtc::scoped_refptr<MediaStreamInterface>> media_streams;
for (const std::string& stream_id : stream_ids) { for (const std::string& stream_id : stream_ids) {
rtc::scoped_refptr<MediaStreamInterface> stream = rtc::scoped_refptr<MediaStreamInterface> stream(
remote_streams_->find(stream_id); remote_streams_->find(stream_id));
if (!stream) { if (!stream) {
stream = MediaStreamProxy::Create(rtc::Thread::Current(), stream = MediaStreamProxy::Create(rtc::Thread::Current(),
MediaStream::Create(stream_id)); MediaStream::Create(stream_id));
@ -2577,7 +2578,8 @@ bool SdpOfferAnswerHandler::AddStream(MediaStreamInterface* local_stream) {
return false; return false;
} }
local_streams_->AddStream(local_stream); local_streams_->AddStream(
rtc::scoped_refptr<MediaStreamInterface>(local_stream));
auto observer = std::make_unique<MediaStreamObserver>( auto observer = std::make_unique<MediaStreamObserver>(
local_stream, local_stream,
[this](AudioTrackInterface* audio_track, [this](AudioTrackInterface* audio_track,
@ -4157,8 +4159,8 @@ void SdpOfferAnswerHandler::UpdateRemoteSendersList(
const std::string& sender_id = params.id; const std::string& sender_id = params.id;
uint32_t ssrc = params.first_ssrc(); uint32_t ssrc = params.first_ssrc();
rtc::scoped_refptr<MediaStreamInterface> stream = rtc::scoped_refptr<MediaStreamInterface> stream(
remote_streams_->find(stream_id); remote_streams_->find(stream_id));
if (!stream) { if (!stream) {
// This is a new MediaStream. Create a new remote MediaStream. // This is a new MediaStream. Create a new remote MediaStream.
stream = MediaStreamProxy::Create(rtc::Thread::Current(), stream = MediaStreamProxy::Create(rtc::Thread::Current(),
@ -4178,8 +4180,8 @@ void SdpOfferAnswerHandler::UpdateRemoteSendersList(
// Add default sender if necessary. // Add default sender if necessary.
if (default_sender_needed) { if (default_sender_needed) {
rtc::scoped_refptr<MediaStreamInterface> default_stream = rtc::scoped_refptr<MediaStreamInterface> default_stream(
remote_streams_->find(kDefaultStreamId); remote_streams_->find(kDefaultStreamId));
if (!default_stream) { if (!default_stream) {
// Create the new default MediaStream. // Create the new default MediaStream.
default_stream = MediaStreamProxy::Create( default_stream = MediaStreamProxy::Create(
@ -4426,7 +4428,8 @@ void SdpOfferAnswerHandler::UpdateEndedRemoteMediaStreams() {
for (size_t i = 0; i < remote_streams_->count(); ++i) { for (size_t i = 0; i < remote_streams_->count(); ++i) {
MediaStreamInterface* stream = remote_streams_->at(i); MediaStreamInterface* stream = remote_streams_->at(i);
if (stream->GetAudioTracks().empty() && stream->GetVideoTracks().empty()) { if (stream->GetAudioTracks().empty() && stream->GetVideoTracks().empty()) {
streams_to_remove.push_back(stream); streams_to_remove.push_back(
rtc::scoped_refptr<MediaStreamInterface>(stream));
} }
} }

5
pc/stream_collection.h
View File

@ -12,6 +12,7 @@
#define PC_STREAM_COLLECTION_H_ #define PC_STREAM_COLLECTION_H_
#include <string> #include <string>
#include <utility>
#include <vector> #include <vector>
#include "api/peer_connection_interface.h" #include "api/peer_connection_interface.h"
@ -66,13 +67,13 @@ class StreamCollection : public StreamCollectionInterface {
return NULL; return NULL;
} }
void AddStream(MediaStreamInterface* stream) { void AddStream(rtc::scoped_refptr<MediaStreamInterface> stream) {
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(stream->id()) == 0) if ((*it)->id().compare(stream->id()) == 0)
return; return;
} }
media_streams_.push_back(stream); media_streams_.push_back(std::move(stream));
} }
void RemoveStream(MediaStreamInterface* remove_stream) { void RemoveStream(MediaStreamInterface* remove_stream) {

4
pc/track_media_info_map_unittest.cc
View File

@ -125,7 +125,7 @@ class TrackMediaInfoMapTest : public ::testing::Test {
local_track->kind() == MediaStreamTrackInterface::kAudioKind local_track->kind() == MediaStreamTrackInterface::kAudioKind
? cricket::MEDIA_TYPE_AUDIO ? cricket::MEDIA_TYPE_AUDIO
: cricket::MEDIA_TYPE_VIDEO, : cricket::MEDIA_TYPE_VIDEO,
ssrcs, local_track); ssrcs, rtc::scoped_refptr<MediaStreamTrackInterface>(local_track));
rtp_senders_.push_back(rtp_sender); rtp_senders_.push_back(rtp_sender);
if (local_track->kind() == MediaStreamTrackInterface::kAudioKind) { if (local_track->kind() == MediaStreamTrackInterface::kAudioKind) {
@ -154,7 +154,7 @@ class TrackMediaInfoMapTest : public ::testing::Test {
remote_track->kind() == MediaStreamTrackInterface::kAudioKind remote_track->kind() == MediaStreamTrackInterface::kAudioKind
? cricket::MEDIA_TYPE_AUDIO ? cricket::MEDIA_TYPE_AUDIO
: cricket::MEDIA_TYPE_VIDEO, : cricket::MEDIA_TYPE_VIDEO,
ssrcs, remote_track); ssrcs, rtc::scoped_refptr<MediaStreamTrackInterface>(remote_track));
rtp_receivers_.push_back(rtp_receiver); rtp_receivers_.push_back(rtp_receiver);
if (remote_track->kind() == MediaStreamTrackInterface::kAudioKind) { if (remote_track->kind() == MediaStreamTrackInterface::kAudioKind) {