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(
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;

3
pc/connection_context.cc
View File

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

12
pc/media_stream.cc
View File

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

2
pc/media_stream.h
View File

@ -44,7 +44,7 @@ class MediaStream : public Notifier<MediaStreamInterface> {
private:
template <typename TrackVector, typename Track>
bool AddTrack(TrackVector* Tracks, Track* track);
bool AddTrack(TrackVector* Tracks, rtc::scoped_refptr<Track> track);
template <typename TrackVector>
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) {
TRACE_EVENT0("webrtc", "PeerConnection::RemoveTrack");
return RemoveTrackNew(sender).ok();
return RemoveTrackNew(rtc::scoped_refptr<RtpSenderInterface>(sender)).ok();
}
RTCError PeerConnection::RemoveTrackNew(
@ -1181,7 +1181,8 @@ void PeerConnection::GetStats(RTCStatsCollectorCallback* callback) {
RTC_DCHECK(stats_collector_);
RTC_DCHECK(callback);
RTC_LOG_THREAD_BLOCK_COUNT();
stats_collector_->GetStatsReport(callback);
stats_collector_->GetStatsReport(
rtc::scoped_refptr<RTCStatsCollectorCallback>(callback));
}
void PeerConnection::GetStats(

48
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()) {
RTC_CHECK(network_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());
callee_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>(
callee_ = rtc::make_ref_counted<PeerConnectionTestWrapper>(
"callee", network_thread_.get(), worker_thread_.get());
webrtc::PeerConnectionInterface::IceServer ice_server;
ice_server.uri = "stun:stun.l.google.com:19302";
@ -126,11 +126,13 @@ class PeerConnectionEndToEndBaseTest : public sigslot::has_slots<>,
}
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) {
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.
@ -258,7 +260,7 @@ rtc::scoped_refptr<webrtc::AudioDecoderFactory>
CreateForwardingMockDecoderFactory(
webrtc::AudioDecoderFactory* real_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())
.Times(AtLeast(1))
.WillRepeatedly(Invoke([real_decoder_factory] {
@ -432,26 +434,22 @@ TEST_P(PeerConnectionEndToEndTest, CallWithCustomCodec) {
std::vector<webrtc::AudioCodecPairId> encoder_id1, encoder_id2, decoder_id1,
decoder_id2;
CreatePcs(rtc::scoped_refptr<webrtc::AudioEncoderFactory>(
new rtc::RefCountedObject<IdLoggingAudioEncoderFactory>(
webrtc::CreateAudioEncoderFactory<
AudioEncoderUnicornSparklesRainbow>(),
&encoder_id1)),
rtc::scoped_refptr<webrtc::AudioDecoderFactory>(
new rtc::RefCountedObject<IdLoggingAudioDecoderFactory>(
webrtc::CreateAudioDecoderFactory<
AudioDecoderUnicornSparklesRainbow>(),
&decoder_id1)),
rtc::scoped_refptr<webrtc::AudioEncoderFactory>(
new rtc::RefCountedObject<IdLoggingAudioEncoderFactory>(
webrtc::CreateAudioEncoderFactory<
AudioEncoderUnicornSparklesRainbow>(),
&encoder_id2)),
rtc::scoped_refptr<webrtc::AudioDecoderFactory>(
new rtc::RefCountedObject<IdLoggingAudioDecoderFactory>(
webrtc::CreateAudioDecoderFactory<
AudioDecoderUnicornSparklesRainbow>(),
&decoder_id2)));
CreatePcs(rtc::make_ref_counted<IdLoggingAudioEncoderFactory>(
webrtc::CreateAudioEncoderFactory<
AudioEncoderUnicornSparklesRainbow>(),
&encoder_id1),
rtc::make_ref_counted<IdLoggingAudioDecoderFactory>(
webrtc::CreateAudioDecoderFactory<
AudioDecoderUnicornSparklesRainbow>(),
&decoder_id1),
rtc::make_ref_counted<IdLoggingAudioEncoderFactory>(
webrtc::CreateAudioEncoderFactory<
AudioEncoderUnicornSparklesRainbow>(),
&encoder_id2),
rtc::make_ref_counted<IdLoggingAudioDecoderFactory>(
webrtc::CreateAudioDecoderFactory<
AudioDecoderUnicornSparklesRainbow>(),
&decoder_id2));
GetAndAddUserMedia();
Negotiate();
WaitForCallEstablished();

3
pc/peer_connection_factory.cc
View File

@ -284,7 +284,8 @@ rtc::scoped_refptr<AudioTrackInterface> PeerConnectionFactory::CreateAudioTrack(
const std::string& id,
AudioSourceInterface* source) {
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);
}

4
pc/peer_connection_interface_unittest.cc
View File

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

6
pc/peer_connection_rtp_unittest.cc
View File

@ -738,10 +738,12 @@ TEST_F(PeerConnectionRtpTestPlanB,
// when the first callback is invoked.
callee->pc()->SetRemoteDescription(
std::move(srd1_sdp),
new OnSuccessObserver<decltype(srd1_callback)>(srd1_callback));
rtc::make_ref_counted<OnSuccessObserver<decltype(srd1_callback)>>(
srd1_callback));
callee->pc()->SetRemoteDescription(
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(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
// executed immediately.
callee->pc()->SetRemoteDescription(std::move(offer),
new FakeSetRemoteDescriptionObserver());
callee->pc()->SetRemoteDescription(
std::move(offer),
rtc::make_ref_counted<FakeSetRemoteDescriptionObserver>());
EXPECT_EQ(2u, callee->pc()->GetReceivers().size());
}
@ -693,8 +694,9 @@ TEST_P(PeerConnectionSignalingTest, CreateOfferBlocksSetRemoteDescription) {
// SetRemoteDescription() operation should be chained to be executed
// asynchronously, when CreateOffer() completes.
callee->pc()->CreateOffer(offer_observer, RTCOfferAnswerOptions());
callee->pc()->SetRemoteDescription(std::move(offer),
new FakeSetRemoteDescriptionObserver());
callee->pc()->SetRemoteDescription(
std::move(offer),
rtc::make_ref_counted<FakeSetRemoteDescriptionObserver>());
// CreateOffer() is asynchronous; without message processing this operation
// should not have completed.
EXPECT_FALSE(offer_observer->called());
@ -1113,8 +1115,9 @@ TEST_F(PeerConnectionSignalingUnifiedPlanTest,
// the new observer should also be invoked synchronously - as is ensured by
// other tests.)
RTC_DCHECK(!caller->pc()->GetTransceivers()[0]->mid().has_value());
caller->pc()->SetLocalDescription(std::move(offer),
new FakeSetLocalDescriptionObserver());
caller->pc()->SetLocalDescription(
std::move(offer),
rtc::make_ref_counted<FakeSetLocalDescriptionObserver>());
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(
std::unique_ptr<SessionDescriptionInterface> desc,
RTCError* error_out) {
rtc::scoped_refptr<FakeSetRemoteDescriptionObserver> observer =
new FakeSetRemoteDescriptionObserver();
auto observer = rtc::make_ref_counted<FakeSetRemoteDescriptionObserver>();
pc()->SetRemoteDescription(std::move(desc), observer);
EXPECT_EQ_WAIT(true, observer->called(), kDefaultTimeout);
bool ok = observer->error().ok();

15
pc/rtc_stats_collector.cc
View File

@ -1224,7 +1224,8 @@ void RTCStatsCollector::GetStatsReportInternal(
std::vector<RequestInfo> requests_;
};
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_) {
// Only start gathering stats if we're not already gathering stats. In the
// 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_) {
std::vector<rtc::scoped_refptr<RtpSenderInternal>> 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,
senders, report);
std::vector<rtc::scoped_refptr<RtpReceiverInternal>> 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,
receivers, report);
@ -2210,11 +2213,13 @@ void RTCStatsCollector::PrepareTransceiverStatsInfosAndCallStats_s_w_n() {
}
std::vector<rtc::scoped_refptr<RtpSenderInternal>> 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;
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>(
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) {
pc_->AddSctpDataChannel(
new MockSctpDataChannel(/*id=*/-1, DataChannelInterface::kConnecting));
pc_->AddSctpDataChannel(
new MockSctpDataChannel(/*id=*/-1, DataChannelInterface::kConnecting));
pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
/*id=*/-1, DataChannelInterface::kConnecting));
pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
/*id=*/-1, DataChannelInterface::kConnecting));
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
// the test, we reset the ID allocator at test start.
SctpDataChannel::ResetInternalIdAllocatorForTesting(-1);
pc_->AddSctpDataChannel(new MockSctpDataChannel(
pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
0, "MockSctpDataChannel0", DataChannelInterface::kConnecting, "udp", 1, 2,
3, 4));
RTCDataChannelStats expected_data_channel0("RTCDataChannel_0", 0);
@ -1178,9 +1178,9 @@ TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
expected_data_channel0.messages_received = 3;
expected_data_channel0.bytes_received = 4;
pc_->AddSctpDataChannel(new MockSctpDataChannel(1, "MockSctpDataChannel1",
DataChannelInterface::kOpen,
"tcp", 5, 6, 7, 8));
pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
1, "MockSctpDataChannel1", DataChannelInterface::kOpen, "tcp", 5, 6, 7,
8));
RTCDataChannelStats expected_data_channel1("RTCDataChannel_1", 0);
expected_data_channel1.label = "MockSctpDataChannel1";
expected_data_channel1.protocol = "tcp";
@ -1191,7 +1191,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
expected_data_channel1.messages_received = 7;
expected_data_channel1.bytes_received = 8;
pc_->AddSctpDataChannel(new MockSctpDataChannel(
pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
2, "MockSctpDataChannel2", DataChannelInterface::kClosing, "udp", 9, 10,
11, 12));
RTCDataChannelStats expected_data_channel2("RTCDataChannel_2", 0);
@ -1204,9 +1204,9 @@ TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
expected_data_channel2.messages_received = 11;
expected_data_channel2.bytes_received = 12;
pc_->AddSctpDataChannel(new MockSctpDataChannel(3, "MockSctpDataChannel3",
DataChannelInterface::kClosed,
"tcp", 13, 14, 15, 16));
pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
3, "MockSctpDataChannel3", DataChannelInterface::kClosed, "tcp", 13, 14,
15, 16));
RTCDataChannelStats expected_data_channel3("RTCDataChannel_3", 0);
expected_data_channel3.label = "MockSctpDataChannel3";
expected_data_channel3.protocol = "tcp";
@ -3358,8 +3358,9 @@ class FakeRTCStatsCollector : public RTCStatsCollector,
static rtc::scoped_refptr<FakeRTCStatsCollector> Create(
PeerConnectionInternal* pc,
int64_t cache_lifetime_us) {
return new rtc::RefCountedObject<FakeRTCStatsCollector>(pc,
cache_lifetime_us);
return rtc::scoped_refptr<FakeRTCStatsCollector>(
new rtc::RefCountedObject<FakeRTCStatsCollector>(pc,
cache_lifetime_us));
}
// 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;
options.echo_cancellation = true;
auto source = LocalAudioSource::Create(&options);
CreateAudioRtpSender(source.get());
CreateAudioRtpSender(source);
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_DCHECK(unified_plan_);
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()
const {
RTC_DCHECK(unified_plan_);
RTC_CHECK_EQ(1u, receivers_.size());
return receivers_[0]->internal();
return rtc::scoped_refptr<RtpReceiverInternal>(receivers_[0]->internal());
}
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.
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()}, {});
new_sender->internal()->SetMediaChannel(voice_media_channel());
GetAudioTransceiver()->internal()->AddSender(new_sender);
@ -424,7 +425,8 @@ void RtpTransmissionManager::AddVideoTrack(VideoTrackInterface* track,
}
// 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()}, {});
new_sender->internal()->SetMediaChannel(video_media_channel());
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());
SetLocalDescription(
rtc::make_ref_counted<SetSessionDescriptionObserverAdapter>(
weak_ptr_factory_.GetWeakPtr(), observer));
weak_ptr_factory_.GetWeakPtr(),
rtc::scoped_refptr<SetSessionDescriptionObserver>(observer)));
}
void SdpOfferAnswerHandler::SetLocalDescription(
@ -2238,8 +2239,8 @@ void SdpOfferAnswerHandler::SetAssociatedRemoteStreams(
RTC_DCHECK_RUN_ON(signaling_thread());
std::vector<rtc::scoped_refptr<MediaStreamInterface>> media_streams;
for (const std::string& stream_id : stream_ids) {
rtc::scoped_refptr<MediaStreamInterface> stream =
remote_streams_->find(stream_id);
rtc::scoped_refptr<MediaStreamInterface> stream(
remote_streams_->find(stream_id));
if (!stream) {
stream = MediaStreamProxy::Create(rtc::Thread::Current(),
MediaStream::Create(stream_id));
@ -2577,7 +2578,8 @@ bool SdpOfferAnswerHandler::AddStream(MediaStreamInterface* local_stream) {
return false;
}
local_streams_->AddStream(local_stream);
local_streams_->AddStream(
rtc::scoped_refptr<MediaStreamInterface>(local_stream));
auto observer = std::make_unique<MediaStreamObserver>(
local_stream,
[this](AudioTrackInterface* audio_track,
@ -4157,8 +4159,8 @@ void SdpOfferAnswerHandler::UpdateRemoteSendersList(
const std::string& sender_id = params.id;
uint32_t ssrc = params.first_ssrc();
rtc::scoped_refptr<MediaStreamInterface> stream =
remote_streams_->find(stream_id);
rtc::scoped_refptr<MediaStreamInterface> stream(
remote_streams_->find(stream_id));
if (!stream) {
// This is a new MediaStream. Create a new remote MediaStream.
stream = MediaStreamProxy::Create(rtc::Thread::Current(),
@ -4178,8 +4180,8 @@ void SdpOfferAnswerHandler::UpdateRemoteSendersList(
// Add default sender if necessary.
if (default_sender_needed) {
rtc::scoped_refptr<MediaStreamInterface> default_stream =
remote_streams_->find(kDefaultStreamId);
rtc::scoped_refptr<MediaStreamInterface> default_stream(
remote_streams_->find(kDefaultStreamId));
if (!default_stream) {
// Create the new default MediaStream.
default_stream = MediaStreamProxy::Create(
@ -4426,7 +4428,8 @@ void SdpOfferAnswerHandler::UpdateEndedRemoteMediaStreams() {
for (size_t i = 0; i < remote_streams_->count(); ++i) {
MediaStreamInterface* stream = remote_streams_->at(i);
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_
#include <string>
#include <utility>
#include <vector>
#include "api/peer_connection_interface.h"
@ -66,13 +67,13 @@ class StreamCollection : public StreamCollectionInterface {
return NULL;
}
void AddStream(MediaStreamInterface* stream) {
void AddStream(rtc::scoped_refptr<MediaStreamInterface> stream) {
for (StreamVector::iterator it = media_streams_.begin();
it != media_streams_.end(); ++it) {
if ((*it)->id().compare(stream->id()) == 0)
return;
}
media_streams_.push_back(stream);
media_streams_.push_back(std::move(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
? cricket::MEDIA_TYPE_AUDIO
: cricket::MEDIA_TYPE_VIDEO,
ssrcs, local_track);
ssrcs, rtc::scoped_refptr<MediaStreamTrackInterface>(local_track));
rtp_senders_.push_back(rtp_sender);
if (local_track->kind() == MediaStreamTrackInterface::kAudioKind) {
@ -154,7 +154,7 @@ class TrackMediaInfoMapTest : public ::testing::Test {
remote_track->kind() == MediaStreamTrackInterface::kAudioKind
? cricket::MEDIA_TYPE_AUDIO
: cricket::MEDIA_TYPE_VIDEO,
ssrcs, remote_track);
ssrcs, rtc::scoped_refptr<MediaStreamTrackInterface>(remote_track));
rtp_receivers_.push_back(rtp_receiver);
if (remote_track->kind() == MediaStreamTrackInterface::kAudioKind) {