Use webrtc name specifier instead of rtc/cricket in pc
WebRTC has unified all namespaces to webrtc, and the rtc:: and cricket::
name specifiers need to be replaced with webrtc::. This was generated using
a combination of clang AST rewriting tools and sed.
This CL was uploaded by git cl split.
Bug: webrtc:42232595
Change-Id: Ib7dd9291d727a1bc177d07960d19395b7e4fca2a
No-Iwyu: LSC
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/386649
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Auto-Submit: Evan Shrubsole <eshr@webrtc.org>
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#44387}
diff --git a/pc/audio_rtp_receiver.cc b/pc/audio_rtp_receiver.cc
index b901355..10bd129 100644
--- a/pc/audio_rtp_receiver.cc
+++ b/pc/audio_rtp_receiver.cc
@@ -53,12 +53,12 @@
AudioRtpReceiver::AudioRtpReceiver(
Thread* worker_thread,
const std::string& receiver_id,
- const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams,
+ const std::vector<scoped_refptr<MediaStreamInterface>>& streams,
bool is_unified_plan,
VoiceMediaReceiveChannelInterface* voice_channel /*= nullptr*/)
: worker_thread_(worker_thread),
id_(receiver_id),
- source_(rtc::make_ref_counted<RemoteAudioSource>(
+ source_(make_ref_counted<RemoteAudioSource>(
worker_thread,
is_unified_plan
? RemoteAudioSource::OnAudioChannelGoneAction::kSurvive
@@ -128,8 +128,7 @@
});
}
-rtc::scoped_refptr<DtlsTransportInterface> AudioRtpReceiver::dtls_transport()
- const {
+scoped_refptr<DtlsTransportInterface> AudioRtpReceiver::dtls_transport() const {
RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
return dtls_transport_;
}
@@ -142,8 +141,8 @@
return stream_ids;
}
-std::vector<rtc::scoped_refptr<MediaStreamInterface>>
-AudioRtpReceiver::streams() const {
+std::vector<scoped_refptr<MediaStreamInterface>> AudioRtpReceiver::streams()
+ const {
RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
return streams_;
}
@@ -159,7 +158,7 @@
}
void AudioRtpReceiver::SetFrameDecryptor(
- rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
+ scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
RTC_DCHECK_RUN_ON(worker_thread_);
frame_decryptor_ = std::move(frame_decryptor);
// Special Case: Set the frame decryptor to any value on any existing channel.
@@ -168,8 +167,8 @@
}
}
-rtc::scoped_refptr<FrameDecryptorInterface>
-AudioRtpReceiver::GetFrameDecryptor() const {
+scoped_refptr<FrameDecryptorInterface> AudioRtpReceiver::GetFrameDecryptor()
+ const {
RTC_DCHECK_RUN_ON(worker_thread_);
return frame_decryptor_;
}
@@ -244,13 +243,13 @@
}
void AudioRtpReceiver::set_transport(
- rtc::scoped_refptr<DtlsTransportInterface> dtls_transport) {
+ scoped_refptr<DtlsTransportInterface> dtls_transport) {
RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
dtls_transport_ = std::move(dtls_transport);
}
void AudioRtpReceiver::SetStreams(
- const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
+ const std::vector<scoped_refptr<MediaStreamInterface>>& streams) {
RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
// Remove remote track from any streams that are going away.
for (const auto& existing_stream : streams_) {
@@ -293,7 +292,7 @@
}
void AudioRtpReceiver::SetFrameTransformer(
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) {
+ scoped_refptr<FrameTransformerInterface> frame_transformer) {
RTC_DCHECK_RUN_ON(worker_thread_);
if (media_channel_) {
media_channel_->SetDepacketizerToDecoderFrameTransformer(
diff --git a/pc/audio_rtp_receiver.h b/pc/audio_rtp_receiver.h
index ebec9b3..df88699 100644
--- a/pc/audio_rtp_receiver.h
+++ b/pc/audio_rtp_receiver.h
@@ -59,7 +59,7 @@
AudioRtpReceiver(
Thread* worker_thread,
const std::string& receiver_id,
- const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams,
+ const std::vector<scoped_refptr<MediaStreamInterface>>& streams,
bool is_unified_plan,
VoiceMediaReceiveChannelInterface* media_channel = nullptr);
virtual ~AudioRtpReceiver();
@@ -70,16 +70,15 @@
// AudioSourceInterface::AudioObserver implementation
void OnSetVolume(double volume) override;
- rtc::scoped_refptr<AudioTrackInterface> audio_track() const { return track_; }
+ scoped_refptr<AudioTrackInterface> audio_track() const { return track_; }
// RtpReceiverInterface implementation
- rtc::scoped_refptr<MediaStreamTrackInterface> track() const override {
+ scoped_refptr<MediaStreamTrackInterface> track() const override {
return track_;
}
- rtc::scoped_refptr<DtlsTransportInterface> dtls_transport() const override;
+ scoped_refptr<DtlsTransportInterface> dtls_transport() const override;
std::vector<std::string> stream_ids() const override;
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams()
- const override;
+ std::vector<scoped_refptr<MediaStreamInterface>> streams() const override;
webrtc::MediaType media_type() const override {
return webrtc::MediaType::AUDIO;
@@ -90,10 +89,9 @@
RtpParameters GetParameters() const override;
void SetFrameDecryptor(
- rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) override;
+ scoped_refptr<FrameDecryptorInterface> frame_decryptor) override;
- rtc::scoped_refptr<FrameDecryptorInterface> GetFrameDecryptor()
- const override;
+ scoped_refptr<FrameDecryptorInterface> GetFrameDecryptor() const override;
// RtpReceiverInternal implementation.
void Stop() override;
@@ -103,9 +101,9 @@
void NotifyFirstPacketReceived() override;
void set_stream_ids(std::vector<std::string> stream_ids) override;
void set_transport(
- rtc::scoped_refptr<DtlsTransportInterface> dtls_transport) override;
- void SetStreams(const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&
- streams) override;
+ scoped_refptr<DtlsTransportInterface> dtls_transport) override;
+ void SetStreams(
+ const std::vector<scoped_refptr<MediaStreamInterface>>& streams) override;
void SetObserver(RtpReceiverObserverInterface* observer) override;
void SetJitterBufferMinimumDelay(
@@ -116,7 +114,7 @@
std::vector<RtpSource> GetSources() const override;
int AttachmentId() const override { return attachment_id_; }
void SetFrameTransformer(
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) override;
+ scoped_refptr<FrameTransformerInterface> frame_transformer) override;
private:
void RestartMediaChannel(std::optional<uint32_t> ssrc)
@@ -131,12 +129,12 @@
RTC_NO_UNIQUE_ADDRESS SequenceChecker signaling_thread_checker_;
Thread* const worker_thread_;
const std::string id_;
- const rtc::scoped_refptr<RemoteAudioSource> source_;
- const rtc::scoped_refptr<AudioTrackProxyWithInternal<AudioTrack>> track_;
+ const scoped_refptr<RemoteAudioSource> source_;
+ const scoped_refptr<AudioTrackProxyWithInternal<AudioTrack>> track_;
VoiceMediaReceiveChannelInterface* media_channel_
RTC_GUARDED_BY(worker_thread_) = nullptr;
std::optional<uint32_t> signaled_ssrc_ RTC_GUARDED_BY(worker_thread_);
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams_
+ std::vector<scoped_refptr<MediaStreamInterface>> streams_
RTC_GUARDED_BY(&signaling_thread_checker_);
bool cached_track_enabled_ RTC_GUARDED_BY(&signaling_thread_checker_);
double cached_volume_ RTC_GUARDED_BY(worker_thread_) = 1.0;
@@ -145,16 +143,16 @@
bool received_first_packet_ RTC_GUARDED_BY(&signaling_thread_checker_) =
false;
const int attachment_id_;
- rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor_
+ scoped_refptr<FrameDecryptorInterface> frame_decryptor_
RTC_GUARDED_BY(worker_thread_);
- rtc::scoped_refptr<DtlsTransportInterface> dtls_transport_
+ scoped_refptr<DtlsTransportInterface> dtls_transport_
RTC_GUARDED_BY(&signaling_thread_checker_);
// Stores and updates the playout delay. Handles caching cases if
// `SetJitterBufferMinimumDelay` is called before start.
JitterBufferDelay delay_ RTC_GUARDED_BY(worker_thread_);
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer_
+ scoped_refptr<FrameTransformerInterface> frame_transformer_
RTC_GUARDED_BY(worker_thread_);
- const rtc::scoped_refptr<PendingTaskSafetyFlag> worker_thread_safety_;
+ const scoped_refptr<PendingTaskSafetyFlag> worker_thread_safety_;
};
} // namespace webrtc
diff --git a/pc/audio_rtp_receiver_unittest.cc b/pc/audio_rtp_receiver_unittest.cc
index fd4e271..91614d7 100644
--- a/pc/audio_rtp_receiver_unittest.cc
+++ b/pc/audio_rtp_receiver_unittest.cc
@@ -41,11 +41,10 @@
protected:
AudioRtpReceiverTest()
: worker_(Thread::Current()),
- receiver_(
- rtc::make_ref_counted<AudioRtpReceiver>(worker_,
- std::string(),
- std::vector<std::string>(),
- false)) {
+ receiver_(make_ref_counted<AudioRtpReceiver>(worker_,
+ std::string(),
+ std::vector<std::string>(),
+ false)) {
EXPECT_CALL(receive_channel_, SetRawAudioSink(kSsrc, _));
EXPECT_CALL(receive_channel_, SetBaseMinimumPlayoutDelayMs(kSsrc, _));
}
@@ -57,7 +56,7 @@
AutoThread main_thread_;
Thread* worker_;
- rtc::scoped_refptr<AudioRtpReceiver> receiver_;
+ scoped_refptr<AudioRtpReceiver> receiver_;
MockVoiceMediaReceiveChannelInterface receive_channel_;
};
@@ -110,9 +109,9 @@
test::RunLoop loop;
auto* thread = Thread::Current(); // Points to loop's thread.
MockVoiceMediaReceiveChannelInterface receive_channel;
- auto receiver = rtc::make_ref_counted<AudioRtpReceiver>(
- thread, std::string(), std::vector<std::string>(), true,
- &receive_channel);
+ auto receiver = make_ref_counted<AudioRtpReceiver>(thread, std::string(),
+ std::vector<std::string>(),
+ true, &receive_channel);
EXPECT_CALL(receive_channel, SetDefaultRawAudioSink(_)).Times(1);
EXPECT_CALL(receive_channel, SetDefaultOutputVolume(kDefaultVolume)).Times(1);
diff --git a/pc/audio_track.cc b/pc/audio_track.cc
index 7d6dc9a..dc446c4 100644
--- a/pc/audio_track.cc
+++ b/pc/audio_track.cc
@@ -22,14 +22,14 @@
namespace webrtc {
// static
-rtc::scoped_refptr<AudioTrack> AudioTrack::Create(
+scoped_refptr<AudioTrack> AudioTrack::Create(
absl::string_view id,
- const rtc::scoped_refptr<AudioSourceInterface>& source) {
- return rtc::make_ref_counted<AudioTrack>(id, source);
+ const scoped_refptr<AudioSourceInterface>& source) {
+ return make_ref_counted<AudioTrack>(id, source);
}
AudioTrack::AudioTrack(absl::string_view label,
- const rtc::scoped_refptr<AudioSourceInterface>& source)
+ const scoped_refptr<AudioSourceInterface>& source)
: MediaStreamTrack<AudioTrackInterface>(label), audio_source_(source) {
if (audio_source_) {
audio_source_->RegisterObserver(this);
diff --git a/pc/audio_track.h b/pc/audio_track.h
index d8e6eed..7b7f5af 100644
--- a/pc/audio_track.h
+++ b/pc/audio_track.h
@@ -31,7 +31,7 @@
protected:
// Protected ctor to force use of factory method.
AudioTrack(absl::string_view label,
- const rtc::scoped_refptr<AudioSourceInterface>& source);
+ const scoped_refptr<AudioSourceInterface>& source);
AudioTrack() = delete;
AudioTrack(const AudioTrack&) = delete;
@@ -40,9 +40,9 @@
~AudioTrack() override;
public:
- static rtc::scoped_refptr<AudioTrack> Create(
+ static scoped_refptr<AudioTrack> Create(
absl::string_view id,
- const rtc::scoped_refptr<AudioSourceInterface>& source);
+ const scoped_refptr<AudioSourceInterface>& source);
// MediaStreamTrack implementation.
std::string kind() const override;
@@ -58,7 +58,7 @@
void OnChanged() override;
private:
- const rtc::scoped_refptr<AudioSourceInterface> audio_source_;
+ const scoped_refptr<AudioSourceInterface> audio_source_;
RTC_NO_UNIQUE_ADDRESS SequenceChecker signaling_thread_checker_;
};
diff --git a/pc/channel.cc b/pc/channel.cc
index 64883cc..deeb8b7 100644
--- a/pc/channel.cc
+++ b/pc/channel.cc
@@ -55,7 +55,7 @@
namespace webrtc {
namespace {
-using ::rtc::UniqueRandomIdGenerator;
+using ::webrtc::UniqueRandomIdGenerator;
// Finds a stream based on target's Primary SSRC or RIDs.
// This struct is used in BaseChannel::UpdateLocalStreams_w.
@@ -183,14 +183,14 @@
rtp_transport_->SubscribeReadyToSend(
this, [this](bool ready) { OnTransportReadyToSend(ready); });
rtp_transport_->SubscribeNetworkRouteChanged(
- this, [this](std::optional<rtc::NetworkRoute> route) {
+ this, [this](std::optional<NetworkRoute> route) {
OnNetworkRouteChanged(route);
});
rtp_transport_->SubscribeWritableState(
this, [this](bool state) { OnWritableState(state); });
rtp_transport_->SubscribeSentPacket(
this,
- [this](const rtc::SentPacket& packet) { SignalSentPacket_n(packet); });
+ [this](const SentPacketInfo& packet) { SignalSentPacket_n(packet); });
return true;
}
@@ -309,12 +309,12 @@
}
bool BaseChannel::SendPacket(CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options) {
+ const AsyncSocketPacketOptions& options) {
return SendPacket(false, packet, options);
}
bool BaseChannel::SendRtcp(CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options) {
+ const AsyncSocketPacketOptions& options) {
return SendPacket(true, packet, options);
}
@@ -391,7 +391,7 @@
bool BaseChannel::SendPacket(bool rtcp,
CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options) {
+ const AsyncSocketPacketOptions& options) {
RTC_DCHECK_RUN_ON(network_thread());
RTC_DCHECK(network_initialized());
TRACE_EVENT0("webrtc", "BaseChannel::SendPacket");
@@ -436,10 +436,8 @@
on_first_packet_sent_ = nullptr;
}
- return rtcp ? rtp_transport_->SendRtcpPacket(packet, options,
- cricket::PF_SRTP_BYPASS)
- : rtp_transport_->SendRtpPacket(packet, options,
- cricket::PF_SRTP_BYPASS);
+ return rtcp ? rtp_transport_->SendRtcpPacket(packet, options, PF_SRTP_BYPASS)
+ : rtp_transport_->SendRtpPacket(packet, options, PF_SRTP_BYPASS);
}
void BaseChannel::OnRtpPacket(const RtpPacketReceived& parsed_packet) {
@@ -655,7 +653,7 @@
// Check for streams that have been removed.
bool ret = true;
- for (const cricket::StreamParams& old_stream : local_streams_) {
+ for (const StreamParams& old_stream : local_streams_) {
if (!old_stream.has_ssrcs() ||
GetStream(streams, StreamFinder(&old_stream))) {
continue;
@@ -670,7 +668,7 @@
}
// Check for new streams.
std::vector<StreamParams> all_streams;
- for (const cricket::StreamParams& stream : streams) {
+ for (const StreamParams& stream : streams) {
StreamParams* existing = GetStream(local_streams_, StreamFinder(&stream));
if (existing) {
// Parameters cannot change for an existing stream.
@@ -736,7 +734,7 @@
const bool old_has_unsignaled_ssrcs = HasStreamWithNoSsrcs(remote_streams_);
// Check for streams that have been removed.
- for (const cricket::StreamParams& old_stream : remote_streams_) {
+ for (const StreamParams& old_stream : remote_streams_) {
// If we no longer have an unsignaled stream, we would like to remove
// the unsignaled stream params that are cached.
if (!old_stream.has_ssrcs() && !new_has_unsignaled_ssrcs) {
@@ -760,7 +758,7 @@
// Check for new streams.
flat_set<uint32_t> ssrcs;
- for (const cricket::StreamParams& new_stream : streams) {
+ for (const StreamParams& new_stream : streams) {
// We allow a StreamParams with an empty list of SSRCs, in which case the
// MediaChannel will cache the parameters and use them for any unsignaled
// stream received later.
@@ -836,7 +834,7 @@
return !was_empty;
}
-void BaseChannel::SignalSentPacket_n(const rtc::SentPacket& sent_packet) {
+void BaseChannel::SignalSentPacket_n(const SentPacketInfo& sent_packet) {
RTC_DCHECK_RUN_ON(network_thread());
RTC_DCHECK(network_initialized());
media_send_channel()->OnPacketSent(sent_packet);
diff --git a/pc/channel.h b/pc/channel.h
index 98fb010..0d367b0 100644
--- a/pc/channel.h
+++ b/pc/channel.h
@@ -220,9 +220,9 @@
// NetworkInterface implementation, called by MediaEngine
bool SendPacket(CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options) override;
+ const AsyncSocketPacketOptions& options) override;
bool SendRtcp(CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options) override;
+ const AsyncSocketPacketOptions& options) override;
// From RtpTransportInternal
void OnWritableState(bool writable);
@@ -231,7 +231,7 @@
bool SendPacket(bool rtcp,
CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options);
+ const AsyncSocketPacketOptions& options);
void EnableMedia_w() RTC_RUN_ON(worker_thread());
void DisableMedia_w() RTC_RUN_ON(worker_thread());
@@ -308,7 +308,7 @@
private:
bool ConnectToRtpTransport_n() RTC_RUN_ON(network_thread());
void DisconnectFromRtpTransport_n() RTC_RUN_ON(network_thread());
- void SignalSentPacket_n(const rtc::SentPacket& sent_packet);
+ void SignalSentPacket_n(const SentPacketInfo& sent_packet);
TaskQueueBase* const worker_thread_;
Thread* const network_thread_;
diff --git a/pc/channel_unittest.cc b/pc/channel_unittest.cc
index d447668..bdb4a05 100644
--- a/pc/channel_unittest.cc
+++ b/pc/channel_unittest.cc
@@ -67,10 +67,10 @@
namespace {
-using ::cricket::DtlsTransportInternal;
using ::testing::AllOf;
using ::testing::ElementsAre;
using ::testing::Field;
+using ::webrtc::DtlsTransportInternal;
using ::webrtc::FakeVoiceMediaReceiveChannel;
using ::webrtc::FakeVoiceMediaSendChannel;
using ::webrtc::RidDescription;
@@ -145,8 +145,8 @@
};
ChannelTest(bool verify_playout,
- rtc::ArrayView<const uint8_t> rtp_data,
- rtc::ArrayView<const uint8_t> rtcp_data,
+ webrtc::ArrayView<const uint8_t> rtp_data,
+ webrtc::ArrayView<const uint8_t> rtcp_data,
NetworkIsWorker network_is_worker)
: verify_playout_(verify_playout),
rtp_packet_(rtp_data.data(), rtp_data.size()),
@@ -469,27 +469,28 @@
return result;
}
- void SendRtp(typename T::MediaSendChannel* media_channel, rtc::Buffer data) {
+ void SendRtp(typename T::MediaSendChannel* media_channel,
+ webrtc::Buffer data) {
network_thread_->PostTask(webrtc::SafeTask(
network_thread_safety_, [media_channel, data = std::move(data)]() {
media_channel->SendPacket(data.data(), data.size(),
- rtc::PacketOptions());
+ webrtc::AsyncSocketPacketOptions());
}));
}
void SendRtp1() {
- SendRtp1(rtc::Buffer(rtp_packet_.data(), rtp_packet_.size()));
+ SendRtp1(webrtc::Buffer(rtp_packet_.data(), rtp_packet_.size()));
}
- void SendRtp1(rtc::Buffer data) {
+ void SendRtp1(webrtc::Buffer data) {
SendRtp(media_send_channel1_impl(), std::move(data));
}
void SendRtp2() {
- SendRtp2(rtc::Buffer(rtp_packet_.data(), rtp_packet_.size()));
+ SendRtp2(webrtc::Buffer(rtp_packet_.data(), rtp_packet_.size()));
}
- void SendRtp2(rtc::Buffer data) {
+ void SendRtp2(webrtc::Buffer data) {
SendRtp(media_send_channel2_impl(), std::move(data));
}
@@ -511,15 +512,17 @@
}
// Methods to check custom data.
bool CheckCustomRtp1(uint32_t ssrc, int sequence_number, int pl_type = -1) {
- rtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type);
+ webrtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type);
return media_receive_channel1_impl()->CheckRtp(data.data(), data.size());
}
bool CheckCustomRtp2(uint32_t ssrc, int sequence_number, int pl_type = -1) {
- rtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type);
+ webrtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type);
return media_receive_channel2_impl()->CheckRtp(data.data(), data.size());
}
- rtc::Buffer CreateRtpData(uint32_t ssrc, int sequence_number, int pl_type) {
- rtc::Buffer data(rtp_packet_.data(), rtp_packet_.size());
+ webrtc::Buffer CreateRtpData(uint32_t ssrc,
+ int sequence_number,
+ int pl_type) {
+ webrtc::Buffer data(rtp_packet_.data(), rtp_packet_.size());
// Set SSRC in the rtp packet copy.
webrtc::SetBE32(data.data() + 8, ssrc);
webrtc::SetBE16(data.data() + 2, sequence_number);
@@ -1488,7 +1491,9 @@
}
protected:
- void WaitForThreads() { WaitForThreads(rtc::ArrayView<rtc::Thread*>()); }
+ void WaitForThreads() {
+ WaitForThreads(webrtc::ArrayView<webrtc::Thread*>());
+ }
static void ProcessThreadQueue(webrtc::Thread* thread) {
RTC_DCHECK(thread->IsCurrent());
while (!thread->empty()) {
@@ -1498,9 +1503,9 @@
static void FlushCurrentThread() {
webrtc::Thread::Current()->ProcessMessages(0);
}
- void WaitForThreads(rtc::ArrayView<rtc::Thread*> threads) {
+ void WaitForThreads(webrtc::ArrayView<webrtc::Thread*> threads) {
// `threads` and current thread post packets to network thread.
- for (rtc::Thread* thread : threads) {
+ for (webrtc::Thread* thread : threads) {
SendTask(thread, [thread] { ProcessThreadQueue(thread); });
}
ProcessThreadQueue(webrtc::Thread::Current());
@@ -1562,7 +1567,7 @@
// TODO(pbos): Remove playout from all media channels and let renderers mute
// themselves.
const bool verify_playout_;
- rtc::scoped_refptr<webrtc::PendingTaskSafetyFlag> network_thread_safety_ =
+ webrtc::scoped_refptr<webrtc::PendingTaskSafetyFlag> network_thread_safety_ =
webrtc::PendingTaskSafetyFlag::CreateDetached();
std::unique_ptr<webrtc::Thread> network_thread_keeper_;
webrtc::Thread* network_thread_;
@@ -1585,8 +1590,8 @@
typename T::Content remote_media_content1_;
typename T::Content remote_media_content2_;
// The RTP and RTCP packets to send in the tests.
- rtc::Buffer rtp_packet_;
- rtc::Buffer rtcp_packet_;
+ webrtc::Buffer rtp_packet_;
+ webrtc::Buffer rtcp_packet_;
webrtc::CandidatePairInterface* last_selected_candidate_pair_;
webrtc::UniqueRandomIdGenerator ssrc_generator_;
webrtc::test::ScopedKeyValueConfig field_trials_;
diff --git a/pc/codec_vendor.cc b/pc/codec_vendor.cc
index 444832e..b7f6423 100644
--- a/pc/codec_vendor.cc
+++ b/pc/codec_vendor.cc
@@ -287,7 +287,7 @@
continue;
}
- rtx_codec.params[cricket::kCodecParamAssociatedPayloadType] =
+ rtx_codec.params[kCodecParamAssociatedPayloadType] =
absl::StrCat(matching_codec->id);
used_pltypes->FindAndSetIdUsed(&rtx_codec);
offered_codecs.push_back(rtx_codec);
@@ -307,7 +307,7 @@
continue;
}
- red_codec.params[cricket::kCodecParamNotInNameValueFormat] =
+ red_codec.params[kCodecParamNotInNameValueFormat] =
absl::StrCat(matching_codec->id) + "/" +
absl::StrCat(matching_codec->id);
}
diff --git a/pc/codec_vendor_unittest.cc b/pc/codec_vendor_unittest.cc
index a9ed68a..f4cfef0 100644
--- a/pc/codec_vendor_unittest.cc
+++ b/pc/codec_vendor_unittest.cc
@@ -38,7 +38,7 @@
namespace webrtc {
namespace {
-using cricket::FakeMediaEngine;
+using webrtc::FakeMediaEngine;
using testing::Contains;
using testing::Eq;
diff --git a/pc/connection_context.cc b/pc/connection_context.cc
index ac7bedb..0e208ea 100644
--- a/pc/connection_context.cc
+++ b/pc/connection_context.cc
@@ -57,7 +57,7 @@
}
auto this_thread = Thread::Current();
if (!this_thread) {
- // If this thread isn't already wrapped by an rtc::Thread, create a
+ // If this thread isn't already wrapped by an webrtc::Thread, create a
// wrapper and own it in this class.
this_thread = ThreadManager::Instance()->WrapCurrentThread();
wraps_current_thread = true;
@@ -81,10 +81,10 @@
} // namespace
// Static
-rtc::scoped_refptr<ConnectionContext> ConnectionContext::Create(
+scoped_refptr<ConnectionContext> ConnectionContext::Create(
const Environment& env,
PeerConnectionFactoryDependencies* dependencies) {
- return rtc::scoped_refptr<ConnectionContext>(
+ return scoped_refptr<ConnectionContext>(
new ConnectionContext(env, dependencies));
}
@@ -150,8 +150,8 @@
// TODO(bugs.webrtc.org/13145): This case should be deleted. Either
// require that a PacketSocketFactory and NetworkManager always are
// injected (with no need to construct these default objects), or require
- // that if a network_thread is injected, an approprite rtc::SocketServer
- // should be injected too.
+ // that if a network_thread is injected, an approprite
+ // webrtc::SocketServer should be injected too.
socket_factory = network_thread()->socketserver();
}
}
diff --git a/pc/connection_context.h b/pc/connection_context.h
index 60f1ef6..9d27561 100644
--- a/pc/connection_context.h
+++ b/pc/connection_context.h
@@ -42,7 +42,7 @@
// Creates a ConnectionContext. May return null if initialization fails.
// The Dependencies class allows simple management of all new dependencies
// being added to the ConnectionContext.
- static rtc::scoped_refptr<ConnectionContext> Create(
+ static scoped_refptr<ConnectionContext> Create(
const Environment& env,
PeerConnectionFactoryDependencies* dependencies);
diff --git a/pc/data_channel_controller.cc b/pc/data_channel_controller.cc
index 63cf193..f8018d7 100644
--- a/pc/data_channel_controller.cc
+++ b/pc/data_channel_controller.cc
@@ -69,10 +69,9 @@
event_observer_ = std::move(observer);
}
-RTCError DataChannelController::SendData(
- StreamId sid,
- const SendDataParams& params,
- const rtc::CopyOnWriteBuffer& payload) {
+RTCError DataChannelController::SendData(StreamId sid,
+ const SendDataParams& params,
+ const CopyOnWriteBuffer& payload) {
RTC_DCHECK_RUN_ON(network_thread());
if (!data_channel_transport_) {
RTC_LOG(LS_ERROR) << "SendData called before transport is ready";
@@ -157,10 +156,9 @@
bytes);
}
-void DataChannelController::OnDataReceived(
- int channel_id,
- DataMessageType type,
- const rtc::CopyOnWriteBuffer& buffer) {
+void DataChannelController::OnDataReceived(int channel_id,
+ DataMessageType type,
+ const CopyOnWriteBuffer& buffer) {
RTC_DCHECK_RUN_ON(network_thread());
if (HandleOpenMessage_n(channel_id, type, buffer))
@@ -200,7 +198,7 @@
[&](const auto& c) { return c->sid_n() == sid; });
if (it != sctp_data_channels_n_.end()) {
- rtc::scoped_refptr<SctpDataChannel> channel = std::move(*it);
+ scoped_refptr<SctpDataChannel> channel = std::move(*it);
sctp_data_channels_n_.erase(it);
channel->OnClosingProcedureComplete();
}
@@ -229,7 +227,7 @@
// `OnSctpDataChannelClosed`. We'll empty `sctp_data_channels_n_`, first
// and `OnSctpDataChannelClosed` will become a noop but we'll release the
// StreamId here.
- std::vector<rtc::scoped_refptr<SctpDataChannel>> temp_sctp_dcs;
+ std::vector<scoped_refptr<SctpDataChannel>> temp_sctp_dcs;
temp_sctp_dcs.swap(sctp_data_channels_n_);
for (const auto& channel : temp_sctp_dcs) {
channel->OnTransportChannelClosed(error);
@@ -295,7 +293,7 @@
bool DataChannelController::HandleOpenMessage_n(
int channel_id,
DataMessageType type,
- const rtc::CopyOnWriteBuffer& buffer) {
+ const CopyOnWriteBuffer& buffer) {
if (type != DataMessageType::kControl || !IsOpenMessage(buffer))
return false;
@@ -327,7 +325,7 @@
}
void DataChannelController::OnDataChannelOpenMessage(
- rtc::scoped_refptr<SctpDataChannel> channel,
+ scoped_refptr<SctpDataChannel> channel,
bool ready_to_send) {
channel_usage_ = DataChannelUsage::kInUse;
auto proxy = SctpDataChannel::CreateProxy(channel, signaling_safety_.flag());
@@ -369,7 +367,7 @@
}
// RTC_RUN_ON(network_thread())
-RTCErrorOr<rtc::scoped_refptr<SctpDataChannel>>
+RTCErrorOr<scoped_refptr<SctpDataChannel>>
DataChannelController::CreateDataChannel(const std::string& label,
InternalDataChannelInit& config) {
std::optional<StreamId> sid = std::nullopt;
@@ -389,7 +387,7 @@
config.id = sid->stream_id_int();
}
- rtc::scoped_refptr<SctpDataChannel> channel = SctpDataChannel::Create(
+ scoped_refptr<SctpDataChannel> channel = SctpDataChannel::Create(
weak_factory_.GetWeakPtr(), label, data_channel_transport_ != nullptr,
config, signaling_thread(), network_thread());
RTC_DCHECK(channel);
@@ -403,7 +401,7 @@
return channel;
}
-RTCErrorOr<rtc::scoped_refptr<DataChannelInterface>>
+RTCErrorOr<scoped_refptr<DataChannelInterface>>
DataChannelController::InternalCreateDataChannelWithProxy(
const std::string& label,
const InternalDataChannelInit& config) {
@@ -417,7 +415,7 @@
bool ready_to_send = false;
InternalDataChannelInit new_config = config;
auto ret = network_thread()->BlockingCall(
- [&]() -> RTCErrorOr<rtc::scoped_refptr<SctpDataChannel>> {
+ [&]() -> RTCErrorOr<scoped_refptr<SctpDataChannel>> {
RTC_DCHECK_RUN_ON(network_thread());
auto channel = CreateDataChannel(label, new_config);
if (!channel.ok())
@@ -454,7 +452,7 @@
data_channel_transport_ && data_channel_transport_->IsReadyToSend();
std::vector<std::pair<SctpDataChannel*, StreamId>> channels_to_update;
- std::vector<rtc::scoped_refptr<SctpDataChannel>> channels_to_close;
+ std::vector<scoped_refptr<SctpDataChannel>> channels_to_close;
for (auto it = sctp_data_channels_n_.begin();
it != sctp_data_channels_n_.end();) {
if (!(*it)->sid_n().has_value()) {
@@ -538,7 +536,7 @@
? Message::DataType::kBinary
: Message::DataType::kString;
message.set_data_type(data_type);
- message.set_unix_timestamp_ms(rtc::TimeUTCMillis());
+ message.set_unix_timestamp_ms(TimeUTCMillis());
message.set_datachannel_id(sid.stream_id_int());
message.set_label((*it)->label());
message.set_direction(direction);
diff --git a/pc/data_channel_controller.h b/pc/data_channel_controller.h
index a204a09..b9e8c60 100644
--- a/pc/data_channel_controller.h
+++ b/pc/data_channel_controller.h
@@ -56,7 +56,7 @@
// SctpDataChannelProviderInterface.
RTCError SendData(StreamId sid,
const SendDataParams& params,
- const rtc::CopyOnWriteBuffer& payload) override;
+ const CopyOnWriteBuffer& payload) override;
void AddSctpDataStream(StreamId sid, PriorityValue priority) override;
void RemoveSctpDataStream(StreamId sid) override;
void OnChannelStateChanged(SctpDataChannel* channel,
@@ -68,7 +68,7 @@
// Implements DataChannelSink.
void OnDataReceived(int channel_id,
DataMessageType type,
- const rtc::CopyOnWriteBuffer& buffer) override;
+ const CopyOnWriteBuffer& buffer) override;
void OnChannelClosing(int channel_id) override;
void OnChannelClosed(int channel_id) override;
void OnReadyToSend() override;
@@ -93,7 +93,7 @@
// Creates channel and adds it to the collection of DataChannels that will
// be offered in a SessionDescription, and wraps it in a proxy object.
- RTCErrorOr<rtc::scoped_refptr<DataChannelInterface>>
+ RTCErrorOr<scoped_refptr<DataChannelInterface>>
InternalCreateDataChannelWithProxy(const std::string& label,
const InternalDataChannelInit& config);
void AllocateSctpSids(SSLRole role);
@@ -116,7 +116,7 @@
void OnSctpDataChannelClosed(SctpDataChannel* channel);
// Creates a new SctpDataChannel object on the network thread.
- RTCErrorOr<rtc::scoped_refptr<SctpDataChannel>> CreateDataChannel(
+ RTCErrorOr<scoped_refptr<SctpDataChannel>> CreateDataChannel(
const std::string& label,
InternalDataChannelInit& config) RTC_RUN_ON(network_thread());
@@ -124,10 +124,10 @@
// message and should be considered to be handled, false otherwise.
bool HandleOpenMessage_n(int channel_id,
DataMessageType type,
- const rtc::CopyOnWriteBuffer& buffer)
+ const CopyOnWriteBuffer& buffer)
RTC_RUN_ON(network_thread());
// Called when a valid data channel OPEN message is received.
- void OnDataChannelOpenMessage(rtc::scoped_refptr<SctpDataChannel> channel,
+ void OnDataChannelOpenMessage(scoped_refptr<SctpDataChannel> channel,
bool ready_to_send)
RTC_RUN_ON(signaling_thread());
@@ -163,7 +163,7 @@
DataChannelTransportInterface* data_channel_transport_
RTC_GUARDED_BY(network_thread()) = nullptr;
SctpSidAllocator sid_allocator_ RTC_GUARDED_BY(network_thread());
- std::vector<rtc::scoped_refptr<SctpDataChannel>> sctp_data_channels_n_
+ std::vector<scoped_refptr<SctpDataChannel>> sctp_data_channels_n_
RTC_GUARDED_BY(network_thread());
enum class DataChannelUsage : uint8_t {
kNeverUsed = 0,
diff --git a/pc/data_channel_controller_unittest.cc b/pc/data_channel_controller_unittest.cc
index 93c4c6c..88f8a9e 100644
--- a/pc/data_channel_controller_unittest.cc
+++ b/pc/data_channel_controller_unittest.cc
@@ -64,7 +64,7 @@
SendData,
(int channel_id,
const SendDataParams& params,
- const rtc::CopyOnWriteBuffer& buffer),
+ const webrtc::CopyOnWriteBuffer& buffer),
(override));
MOCK_METHOD(RTCError, CloseChannel, (int channel_id), (override));
MOCK_METHOD(void, SetDataSink, (DataChannelSink * sink), (override));
@@ -118,7 +118,7 @@
DataChannelControllerTest()
: network_thread_(std::make_unique<NullSocketServer>()) {
network_thread_.Start();
- pc_ = rtc::make_ref_counted<NiceMock<MockPeerConnectionInternal>>();
+ pc_ = make_ref_counted<NiceMock<MockPeerConnectionInternal>>();
ON_CALL(*pc_, signaling_thread).WillByDefault(Return(Thread::Current()));
ON_CALL(*pc_, network_thread).WillByDefault(Return(&network_thread_));
}
@@ -131,7 +131,7 @@
ScopedBaseFakeClock clock_;
test::RunLoop run_loop_;
Thread network_thread_;
- rtc::scoped_refptr<NiceMock<MockPeerConnectionInternal>> pc_;
+ scoped_refptr<NiceMock<MockPeerConnectionInternal>> pc_;
};
TEST_F(DataChannelControllerTest, CreateAndDestroy) {
diff --git a/pc/data_channel_integrationtest.cc b/pc/data_channel_integrationtest.cc
index 6853a18..de87405 100644
--- a/pc/data_channel_integrationtest.cc
+++ b/pc/data_channel_integrationtest.cc
@@ -134,7 +134,7 @@
std::unique_ptr<SessionDescriptionInterface>& desc) {
auto& transport_infos = desc->description()->transport_infos();
for (auto& transport_info : transport_infos) {
- transport_info.description.connection_role = cricket::CONNECTIONROLE_ACTIVE;
+ transport_info.description.connection_role = CONNECTIONROLE_ACTIVE;
}
}
@@ -142,8 +142,7 @@
std::unique_ptr<SessionDescriptionInterface>& desc) {
auto& transport_infos = desc->description()->transport_infos();
for (auto& transport_info : transport_infos) {
- transport_info.description.connection_role =
- cricket::CONNECTIONROLE_PASSIVE;
+ transport_info.description.connection_role = CONNECTIONROLE_PASSIVE;
}
}
@@ -434,7 +433,7 @@
EXPECT_FALSE(caller()->data_observer()->messages().back().binary);
// Sending empty binary data
- rtc::CopyOnWriteBuffer empty_buffer;
+ CopyOnWriteBuffer empty_buffer;
caller()->data_channel()->Send(DataBuffer(empty_buffer, true));
EXPECT_THAT(
WaitUntil(
@@ -1513,10 +1512,9 @@
bool addTurn) {
RTCConfiguration config;
if (addTurn) {
- static const rtc::SocketAddress turn_server_1_internal_address{
- "192.0.2.1", 3478};
- static const rtc::SocketAddress turn_server_1_external_address{
- "192.0.3.1", 0};
+ static const SocketAddress turn_server_1_internal_address{"192.0.2.1",
+ 3478};
+ static const SocketAddress turn_server_1_external_address{"192.0.3.1", 0};
TestTurnServer* turn_server_1 = CreateTurnServer(
turn_server_1_internal_address, turn_server_1_external_address);
diff --git a/pc/data_channel_unittest.cc b/pc/data_channel_unittest.cc
index d81db2c..293d33f 100644
--- a/pc/data_channel_unittest.cc
+++ b/pc/data_channel_unittest.cc
@@ -120,7 +120,7 @@
// in the SctpDataChannel code is (still) tied to the signaling thread, but
// the `AddSctpDataStream` operation is a bridge to the transport and needs
// to run on the network thread.
- void SetChannelSid(const rtc::scoped_refptr<SctpDataChannel>& channel,
+ void SetChannelSid(const scoped_refptr<SctpDataChannel>& channel,
StreamId sid) {
network_thread_.BlockingCall([&]() {
channel->SetSctpSid_n(sid);
@@ -150,12 +150,12 @@
test::RunLoop run_loop_;
Thread network_thread_;
InternalDataChannelInit init_;
- rtc::scoped_refptr<PendingTaskSafetyFlag> signaling_safety_ =
+ scoped_refptr<PendingTaskSafetyFlag> signaling_safety_ =
PendingTaskSafetyFlag::Create();
std::unique_ptr<FakeDataChannelController> controller_;
std::unique_ptr<FakeDataChannelObserver> observer_;
- rtc::scoped_refptr<SctpDataChannel> inner_channel_;
- rtc::scoped_refptr<DataChannelInterface> channel_;
+ scoped_refptr<SctpDataChannel> inner_channel_;
+ scoped_refptr<DataChannelInterface> channel_;
};
TEST_F(SctpDataChannelTest, VerifyConfigurationGetters) {
@@ -187,7 +187,7 @@
// Verifies that the data channel is connected to the transport after creation.
TEST_F(SctpDataChannelTest, ConnectedToTransportOnCreated) {
controller_->set_transport_available(true);
- rtc::scoped_refptr<SctpDataChannel> dc =
+ scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", init_);
EXPECT_TRUE(controller_->IsConnected(dc.get()));
@@ -257,7 +257,7 @@
InternalDataChannelInit init;
init.id = 1;
init.ordered = false;
- rtc::scoped_refptr<SctpDataChannel> dc =
+ scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", init);
auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
@@ -271,7 +271,7 @@
EXPECT_TRUE(controller_->last_send_data_params().ordered);
// Emulates receiving an OPEN_ACK message.
- rtc::CopyOnWriteBuffer payload;
+ CopyOnWriteBuffer payload;
WriteDataChannelOpenAckMessage(&payload);
network_thread_.BlockingCall(
[&] { dc->OnDataReceived(DataMessageType::kControl, payload); });
@@ -288,7 +288,7 @@
InternalDataChannelInit init;
init.id = 1;
init.ordered = false;
- rtc::scoped_refptr<SctpDataChannel> dc =
+ scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", init);
auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
@@ -302,7 +302,7 @@
EXPECT_TRUE(controller_->last_send_data_params().ordered);
// Emulates receiving an OPEN_ACK message.
- rtc::CopyOnWriteBuffer payload;
+ CopyOnWriteBuffer payload;
WriteDataChannelOpenAckMessage(&payload);
network_thread_.BlockingCall(
[&] { dc->OnDataReceived(DataMessageType::kControl, payload); });
@@ -319,7 +319,7 @@
InternalDataChannelInit init;
init.id = 1;
init.ordered = false;
- rtc::scoped_refptr<SctpDataChannel> dc =
+ scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", init);
auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
@@ -344,7 +344,7 @@
InternalDataChannelInit init;
init.id = 1;
init.ordered = false;
- rtc::scoped_refptr<SctpDataChannel> dc =
+ scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", init);
auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
@@ -405,7 +405,7 @@
config.open_handshake_role = InternalDataChannelInit::kNone;
SetChannelReady();
- rtc::scoped_refptr<SctpDataChannel> dc =
+ scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", config);
auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
@@ -472,7 +472,7 @@
config.open_handshake_role = InternalDataChannelInit::kAcker;
SetChannelReady();
- rtc::scoped_refptr<SctpDataChannel> dc =
+ scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", config);
auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
@@ -528,7 +528,7 @@
// Tests that the DataChannel is closed if the received buffer is full.
TEST_F(SctpDataChannelTest, ClosedWhenReceivedBufferFull) {
SetChannelReady();
- rtc::CopyOnWriteBuffer buffer(1024);
+ CopyOnWriteBuffer buffer(1024);
memset(buffer.MutableData(), 0, buffer.size());
network_thread_.BlockingCall([&] {
@@ -587,7 +587,7 @@
AddObserver();
SetChannelReady();
- rtc::CopyOnWriteBuffer buffer(100 * 1024);
+ CopyOnWriteBuffer buffer(100 * 1024);
memset(buffer.MutableData(), 0, buffer.size());
DataBuffer packet(buffer, true);
@@ -642,10 +642,10 @@
// Verifies that an even SCTP id is allocated for SSL_CLIENT and an odd id for
// SSL_SERVER.
TEST_F(SctpSidAllocatorTest, SctpIdAllocationBasedOnRole) {
- EXPECT_EQ(allocator_.AllocateSid(rtc::SSL_SERVER), StreamId(1));
- EXPECT_EQ(allocator_.AllocateSid(rtc::SSL_CLIENT), StreamId(0));
- EXPECT_EQ(allocator_.AllocateSid(rtc::SSL_SERVER), StreamId(3));
- EXPECT_EQ(allocator_.AllocateSid(rtc::SSL_CLIENT), StreamId(2));
+ EXPECT_EQ(allocator_.AllocateSid(SSL_SERVER), StreamId(1));
+ EXPECT_EQ(allocator_.AllocateSid(SSL_CLIENT), StreamId(0));
+ EXPECT_EQ(allocator_.AllocateSid(SSL_SERVER), StreamId(3));
+ EXPECT_EQ(allocator_.AllocateSid(SSL_CLIENT), StreamId(2));
}
// Verifies that SCTP ids of existing DataChannels are not reused.
@@ -653,13 +653,13 @@
StreamId old_id(1);
EXPECT_TRUE(allocator_.ReserveSid(old_id));
- std::optional<StreamId> new_id = allocator_.AllocateSid(rtc::SSL_SERVER);
+ std::optional<StreamId> new_id = allocator_.AllocateSid(SSL_SERVER);
EXPECT_TRUE(new_id.has_value());
EXPECT_NE(old_id, new_id);
old_id = StreamId(0);
EXPECT_TRUE(allocator_.ReserveSid(old_id));
- new_id = allocator_.AllocateSid(rtc::SSL_CLIENT);
+ new_id = allocator_.AllocateSid(SSL_CLIENT);
EXPECT_TRUE(new_id.has_value());
EXPECT_NE(old_id, new_id);
}
@@ -671,34 +671,33 @@
EXPECT_TRUE(allocator_.ReserveSid(odd_id));
EXPECT_TRUE(allocator_.ReserveSid(even_id));
- std::optional<StreamId> allocated_id =
- allocator_.AllocateSid(rtc::SSL_SERVER);
+ std::optional<StreamId> allocated_id = allocator_.AllocateSid(SSL_SERVER);
EXPECT_EQ(odd_id.stream_id_int() + 2, allocated_id->stream_id_int());
- allocated_id = allocator_.AllocateSid(rtc::SSL_CLIENT);
+ allocated_id = allocator_.AllocateSid(SSL_CLIENT);
EXPECT_EQ(even_id.stream_id_int() + 2, allocated_id->stream_id_int());
- allocated_id = allocator_.AllocateSid(rtc::SSL_SERVER);
+ allocated_id = allocator_.AllocateSid(SSL_SERVER);
EXPECT_EQ(odd_id.stream_id_int() + 4, allocated_id->stream_id_int());
- allocated_id = allocator_.AllocateSid(rtc::SSL_CLIENT);
+ allocated_id = allocator_.AllocateSid(SSL_CLIENT);
EXPECT_EQ(even_id.stream_id_int() + 4, allocated_id->stream_id_int());
allocator_.ReleaseSid(odd_id);
allocator_.ReleaseSid(even_id);
// Verifies that removed ids are reused.
- allocated_id = allocator_.AllocateSid(rtc::SSL_SERVER);
+ allocated_id = allocator_.AllocateSid(SSL_SERVER);
EXPECT_EQ(odd_id, allocated_id);
- allocated_id = allocator_.AllocateSid(rtc::SSL_CLIENT);
+ allocated_id = allocator_.AllocateSid(SSL_CLIENT);
EXPECT_EQ(even_id, allocated_id);
// Verifies that used higher ids are not reused.
- allocated_id = allocator_.AllocateSid(rtc::SSL_SERVER);
+ allocated_id = allocator_.AllocateSid(SSL_SERVER);
EXPECT_EQ(odd_id.stream_id_int() + 6, allocated_id->stream_id_int());
- allocated_id = allocator_.AllocateSid(rtc::SSL_CLIENT);
+ allocated_id = allocator_.AllocateSid(SSL_CLIENT);
EXPECT_EQ(even_id.stream_id_int() + 6, allocated_id->stream_id_int());
}
@@ -737,7 +736,7 @@
} // namespace
TEST(DataChannelInterfaceTest, Coverage) {
- auto channel = rtc::make_ref_counted<NoImplDataChannel>();
+ auto channel = make_ref_counted<NoImplDataChannel>();
EXPECT_FALSE(channel->ordered());
EXPECT_FALSE(channel->maxRetransmitsOpt());
EXPECT_FALSE(channel->maxPacketLifeTime());
@@ -753,12 +752,12 @@
#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
TEST(DataChannelInterfaceDeathTest, SendDefaultImplDchecks) {
- auto channel = rtc::make_ref_counted<NoImplDataChannel>();
+ auto channel = webrtc::make_ref_counted<NoImplDataChannel>();
RTC_EXPECT_DEATH(channel->Send(DataBuffer("Foo")), "Check failed: false");
}
TEST(DataChannelInterfaceDeathTest, SendAsyncDefaultImplDchecks) {
- auto channel = rtc::make_ref_counted<NoImplDataChannel>();
+ auto channel = webrtc::make_ref_counted<NoImplDataChannel>();
RTC_EXPECT_DEATH(channel->SendAsync(DataBuffer("Foo"), nullptr),
"Check failed: false");
}
diff --git a/pc/dtls_srtp_transport.cc b/pc/dtls_srtp_transport.cc
index 10d85b5..10a5291 100644
--- a/pc/dtls_srtp_transport.cc
+++ b/pc/dtls_srtp_transport.cc
@@ -161,8 +161,8 @@
}
int selected_crypto_suite;
- rtc::ZeroOnFreeBuffer<uint8_t> send_key;
- rtc::ZeroOnFreeBuffer<uint8_t> recv_key;
+ ZeroOnFreeBuffer<uint8_t> send_key;
+ ZeroOnFreeBuffer<uint8_t> recv_key;
if (!ExtractParams(rtp_dtls_transport_, &selected_crypto_suite, &send_key,
&recv_key) ||
@@ -190,8 +190,8 @@
}
int selected_crypto_suite;
- rtc::ZeroOnFreeBuffer<uint8_t> rtcp_send_key;
- rtc::ZeroOnFreeBuffer<uint8_t> rtcp_recv_key;
+ ZeroOnFreeBuffer<uint8_t> rtcp_send_key;
+ ZeroOnFreeBuffer<uint8_t> rtcp_recv_key;
if (!ExtractParams(rtcp_dtls_transport_, &selected_crypto_suite,
&rtcp_send_key, &rtcp_recv_key) ||
!SetRtcpParams(selected_crypto_suite, rtcp_send_key, send_extension_ids,
@@ -201,11 +201,10 @@
}
}
-bool DtlsSrtpTransport::ExtractParams(
- DtlsTransportInternal* dtls_transport,
- int* selected_crypto_suite,
- rtc::ZeroOnFreeBuffer<uint8_t>* send_key,
- rtc::ZeroOnFreeBuffer<uint8_t>* recv_key) {
+bool DtlsSrtpTransport::ExtractParams(DtlsTransportInternal* dtls_transport,
+ int* selected_crypto_suite,
+ ZeroOnFreeBuffer<uint8_t>* send_key,
+ ZeroOnFreeBuffer<uint8_t>* recv_key) {
if (!dtls_transport || !dtls_transport->IsDtlsActive()) {
return false;
}
@@ -228,7 +227,7 @@
}
// OK, we're now doing DTLS (RFC 5764)
- rtc::ZeroOnFreeBuffer<uint8_t> dtls_buffer(key_len * 2 + salt_len * 2);
+ ZeroOnFreeBuffer<uint8_t> dtls_buffer(key_len * 2 + salt_len * 2);
// RFC 5705 exporter using the RFC 5764 parameters
if (!dtls_transport->ExportSrtpKeyingMaterial(dtls_buffer)) {
@@ -241,10 +240,10 @@
// https://datatracker.ietf.org/doc/html/rfc5764#section-4.2
// The keying material is in the format:
// client_write_key|server_write_key|client_write_salt|server_write_salt
- rtc::ZeroOnFreeBuffer<uint8_t> client_write_key(&dtls_buffer[0], key_len,
- key_len + salt_len);
- rtc::ZeroOnFreeBuffer<uint8_t> server_write_key(&dtls_buffer[key_len],
- key_len, key_len + salt_len);
+ ZeroOnFreeBuffer<uint8_t> client_write_key(&dtls_buffer[0], key_len,
+ key_len + salt_len);
+ ZeroOnFreeBuffer<uint8_t> server_write_key(&dtls_buffer[key_len], key_len,
+ key_len + salt_len);
client_write_key.AppendData(&dtls_buffer[key_len + key_len], salt_len);
server_write_key.AppendData(&dtls_buffer[key_len + key_len + salt_len],
salt_len);
@@ -281,8 +280,9 @@
if (new_dtls_transport) {
new_dtls_transport->SubscribeDtlsTransportState(
this,
- [this](cricket::DtlsTransportInternal* transport,
- DtlsTransportState state) { OnDtlsState(transport, state); });
+ [this](DtlsTransportInternal* transport, DtlsTransportState state) {
+ OnDtlsState(transport, state);
+ });
}
}
diff --git a/pc/dtls_srtp_transport.h b/pc/dtls_srtp_transport.h
index 2528082..a5592b2 100644
--- a/pc/dtls_srtp_transport.h
+++ b/pc/dtls_srtp_transport.h
@@ -64,8 +64,8 @@
void SetupRtcpDtlsSrtp();
bool ExtractParams(DtlsTransportInternal* dtls_transport,
int* selected_crypto_suite,
- rtc::ZeroOnFreeBuffer<uint8_t>* send_key,
- rtc::ZeroOnFreeBuffer<uint8_t>* recv_key);
+ ZeroOnFreeBuffer<uint8_t>* send_key,
+ ZeroOnFreeBuffer<uint8_t>* recv_key);
void SetDtlsTransport(DtlsTransportInternal* new_dtls_transport,
DtlsTransportInternal** old_dtls_transport);
void SetRtpDtlsTransport(DtlsTransportInternal* rtp_dtls_transport);
diff --git a/pc/dtls_srtp_transport_integrationtest.cc b/pc/dtls_srtp_transport_integrationtest.cc
index a095a2f..1b4990b 100644
--- a/pc/dtls_srtp_transport_integrationtest.cc
+++ b/pc/dtls_srtp_transport_integrationtest.cc
@@ -78,7 +78,7 @@
srtp_transport_.UnregisterRtpDemuxerSink(&srtp_transport_observer_);
}
- rtc::scoped_refptr<webrtc::RTCCertificate> MakeCertificate() {
+ webrtc::scoped_refptr<webrtc::RTCCertificate> MakeCertificate() {
return webrtc::RTCCertificate::Create(
webrtc::SSLIdentity::Create("test", webrtc::KT_DEFAULT));
}
@@ -92,15 +92,15 @@
return ice_transport;
}
- std::unique_ptr<cricket::DtlsTransport> MakeDtlsTransport(
+ std::unique_ptr<webrtc::DtlsTransportInternalImpl> MakeDtlsTransport(
webrtc::FakeIceTransport* ice_transport) {
- return std::make_unique<cricket::DtlsTransport>(
+ return std::make_unique<webrtc::DtlsTransportInternalImpl>(
ice_transport, webrtc::CryptoOptions(),
/*event_log=*/nullptr, webrtc::SSL_PROTOCOL_DTLS_12);
}
void SetRemoteFingerprintFromCert(
- cricket::DtlsTransport* transport,
- const rtc::scoped_refptr<webrtc::RTCCertificate>& cert) {
+ webrtc::DtlsTransportInternalImpl* transport,
+ const webrtc::scoped_refptr<webrtc::RTCCertificate>& cert) {
std::unique_ptr<webrtc::SSLFingerprint> fingerprint =
webrtc::SSLFingerprint::CreateFromCertificate(*cert);
@@ -151,12 +151,12 @@
&key_len, &salt_len));
// Extract the keys. The order depends on the role!
- rtc::ZeroOnFreeBuffer<uint8_t> dtls_buffer(key_len * 2 + salt_len * 2);
+ webrtc::ZeroOnFreeBuffer<uint8_t> dtls_buffer(key_len * 2 + salt_len * 2);
ASSERT_TRUE(server_dtls_transport_->ExportSrtpKeyingMaterial(dtls_buffer));
- rtc::ZeroOnFreeBuffer<unsigned char> client_write_key(
+ webrtc::ZeroOnFreeBuffer<unsigned char> client_write_key(
&dtls_buffer[0], key_len, key_len + salt_len);
- rtc::ZeroOnFreeBuffer<unsigned char> server_write_key(
+ webrtc::ZeroOnFreeBuffer<unsigned char> server_write_key(
&dtls_buffer[key_len], key_len, key_len + salt_len);
client_write_key.AppendData(&dtls_buffer[key_len + key_len], salt_len);
server_write_key.AppendData(&dtls_buffer[key_len + key_len + salt_len],
@@ -167,10 +167,10 @@
client_write_key, {}));
}
- rtc::CopyOnWriteBuffer CreateRtpPacket() {
+ webrtc::CopyOnWriteBuffer CreateRtpPacket() {
size_t rtp_len = sizeof(kPcmuFrame);
size_t packet_size = rtp_len + kRtpAuthTagLen;
- rtc::Buffer rtp_packet_buffer(packet_size);
+ webrtc::Buffer rtp_packet_buffer(packet_size);
char* rtp_packet_data = rtp_packet_buffer.data<char>();
memcpy(rtp_packet_data, kPcmuFrame, rtp_len);
@@ -178,11 +178,11 @@
}
void SendRtpPacketFromSrtpToDtlsSrtp() {
- rtc::PacketOptions options;
- rtc::CopyOnWriteBuffer packet = CreateRtpPacket();
+ webrtc::AsyncSocketPacketOptions options;
+ webrtc::CopyOnWriteBuffer packet = CreateRtpPacket();
EXPECT_TRUE(srtp_transport_.SendRtpPacket(&packet, options,
- cricket::PF_SRTP_BYPASS));
+ webrtc::PF_SRTP_BYPASS));
EXPECT_THAT(webrtc::WaitUntil(
[&] { return dtls_srtp_transport_observer_.rtp_count(); },
::testing::Eq(1),
@@ -198,11 +198,11 @@
}
void SendRtpPacketFromDtlsSrtpToSrtp() {
- rtc::PacketOptions options;
- rtc::CopyOnWriteBuffer packet = CreateRtpPacket();
+ webrtc::AsyncSocketPacketOptions options;
+ webrtc::CopyOnWriteBuffer packet = CreateRtpPacket();
EXPECT_TRUE(dtls_srtp_transport_.SendRtpPacket(&packet, options,
- cricket::PF_SRTP_BYPASS));
+ webrtc::PF_SRTP_BYPASS));
EXPECT_THAT(
webrtc::WaitUntil([&] { return srtp_transport_observer_.rtp_count(); },
::testing::Eq(1),
@@ -224,11 +224,11 @@
std::unique_ptr<webrtc::FakeIceTransport> client_ice_transport_;
std::unique_ptr<webrtc::FakeIceTransport> server_ice_transport_;
- std::unique_ptr<cricket::DtlsTransport> client_dtls_transport_;
- std::unique_ptr<cricket::DtlsTransport> server_dtls_transport_;
+ std::unique_ptr<webrtc::DtlsTransportInternalImpl> client_dtls_transport_;
+ std::unique_ptr<webrtc::DtlsTransportInternalImpl> server_dtls_transport_;
- rtc::scoped_refptr<webrtc::RTCCertificate> client_certificate_;
- rtc::scoped_refptr<webrtc::RTCCertificate> server_certificate_;
+ webrtc::scoped_refptr<webrtc::RTCCertificate> client_certificate_;
+ webrtc::scoped_refptr<webrtc::RTCCertificate> server_certificate_;
webrtc::DtlsSrtpTransport dtls_srtp_transport_;
webrtc::SrtpTransport srtp_transport_;
diff --git a/pc/dtls_srtp_transport_unittest.cc b/pc/dtls_srtp_transport_unittest.cc
index acdfb6c..19499ab 100644
--- a/pc/dtls_srtp_transport_unittest.cc
+++ b/pc/dtls_srtp_transport_unittest.cc
@@ -83,7 +83,7 @@
dtls_srtp_transport1_->SubscribeRtcpPacketReceived(
&transport_observer1_,
- [this](rtc::CopyOnWriteBuffer* buffer, int64_t packet_time_ms) {
+ [this](webrtc::CopyOnWriteBuffer* buffer, int64_t packet_time_ms) {
transport_observer1_.OnRtcpPacketReceived(buffer, packet_time_ms);
});
dtls_srtp_transport1_->SubscribeReadyToSend(
@@ -92,7 +92,7 @@
dtls_srtp_transport2_->SubscribeRtcpPacketReceived(
&transport_observer2_,
- [this](rtc::CopyOnWriteBuffer* buffer, int64_t packet_time_ms) {
+ [this](webrtc::CopyOnWriteBuffer* buffer, int64_t packet_time_ms) {
transport_observer2_.OnRtcpPacketReceived(buffer, packet_time_ms);
});
dtls_srtp_transport2_->SubscribeReadyToSend(
@@ -126,24 +126,24 @@
size_t rtp_len = sizeof(kPcmuFrame);
size_t packet_size = rtp_len + kRtpAuthTagLen;
- rtc::Buffer rtp_packet_buffer(packet_size);
+ webrtc::Buffer rtp_packet_buffer(packet_size);
char* rtp_packet_data = rtp_packet_buffer.data<char>();
memcpy(rtp_packet_data, kPcmuFrame, rtp_len);
// In order to be able to run this test function multiple times we can not
// use the same sequence number twice. Increase the sequence number by one.
webrtc::SetBE16(reinterpret_cast<uint8_t*>(rtp_packet_data) + 2,
++sequence_number_);
- rtc::CopyOnWriteBuffer rtp_packet1to2(rtp_packet_data, rtp_len,
- packet_size);
- rtc::CopyOnWriteBuffer rtp_packet2to1(rtp_packet_data, rtp_len,
- packet_size);
+ webrtc::CopyOnWriteBuffer rtp_packet1to2(rtp_packet_data, rtp_len,
+ packet_size);
+ webrtc::CopyOnWriteBuffer rtp_packet2to1(rtp_packet_data, rtp_len,
+ packet_size);
- rtc::PacketOptions options;
+ webrtc::AsyncSocketPacketOptions options;
// Send a packet from `srtp_transport1_` to `srtp_transport2_` and verify
// that the packet can be successfully received and decrypted.
int prev_received_packets = transport_observer2_.rtp_count();
ASSERT_TRUE(dtls_srtp_transport1_->SendRtpPacket(&rtp_packet1to2, options,
- cricket::PF_SRTP_BYPASS));
+ webrtc::PF_SRTP_BYPASS));
ASSERT_TRUE(transport_observer2_.last_recv_rtp_packet().data());
EXPECT_EQ(0, memcmp(transport_observer2_.last_recv_rtp_packet().data(),
kPcmuFrame, rtp_len));
@@ -151,7 +151,7 @@
prev_received_packets = transport_observer1_.rtp_count();
ASSERT_TRUE(dtls_srtp_transport2_->SendRtpPacket(&rtp_packet2to1, options,
- cricket::PF_SRTP_BYPASS));
+ webrtc::PF_SRTP_BYPASS));
ASSERT_TRUE(transport_observer1_.last_recv_rtp_packet().data());
EXPECT_EQ(0, memcmp(transport_observer1_.last_recv_rtp_packet().data(),
kPcmuFrame, rtp_len));
@@ -161,19 +161,21 @@
void SendRecvRtcpPackets() {
size_t rtcp_len = sizeof(kRtcpReport);
size_t packet_size = rtcp_len + 4 + kRtpAuthTagLen;
- rtc::Buffer rtcp_packet_buffer(packet_size);
+ webrtc::Buffer rtcp_packet_buffer(packet_size);
// TODO(zhihuang): Remove the extra copy when the SendRtpPacket method
// doesn't take the CopyOnWriteBuffer by pointer.
- rtc::CopyOnWriteBuffer rtcp_packet1to2(kRtcpReport, rtcp_len, packet_size);
- rtc::CopyOnWriteBuffer rtcp_packet2to1(kRtcpReport, rtcp_len, packet_size);
+ webrtc::CopyOnWriteBuffer rtcp_packet1to2(kRtcpReport, rtcp_len,
+ packet_size);
+ webrtc::CopyOnWriteBuffer rtcp_packet2to1(kRtcpReport, rtcp_len,
+ packet_size);
- rtc::PacketOptions options;
+ webrtc::AsyncSocketPacketOptions options;
// Send a packet from `srtp_transport1_` to `srtp_transport2_` and verify
// that the packet can be successfully received and decrypted.
int prev_received_packets = transport_observer2_.rtcp_count();
ASSERT_TRUE(dtls_srtp_transport1_->SendRtcpPacket(&rtcp_packet1to2, options,
- cricket::PF_SRTP_BYPASS));
+ webrtc::PF_SRTP_BYPASS));
ASSERT_TRUE(transport_observer2_.last_recv_rtcp_packet().data());
EXPECT_EQ(0, memcmp(transport_observer2_.last_recv_rtcp_packet().data(),
kRtcpReport, rtcp_len));
@@ -182,7 +184,7 @@
// Do the same thing in the opposite direction;
prev_received_packets = transport_observer1_.rtcp_count();
ASSERT_TRUE(dtls_srtp_transport2_->SendRtcpPacket(&rtcp_packet2to1, options,
- cricket::PF_SRTP_BYPASS));
+ webrtc::PF_SRTP_BYPASS));
ASSERT_TRUE(transport_observer1_.last_recv_rtcp_packet().data());
EXPECT_EQ(0, memcmp(transport_observer1_.last_recv_rtcp_packet().data(),
kRtcpReport, rtcp_len));
@@ -198,26 +200,26 @@
size_t rtp_len = sizeof(kPcmuFrameWithExtensions);
size_t packet_size = rtp_len + kRtpAuthTagLen;
- rtc::Buffer rtp_packet_buffer(packet_size);
+ webrtc::Buffer rtp_packet_buffer(packet_size);
char* rtp_packet_data = rtp_packet_buffer.data<char>();
memcpy(rtp_packet_data, kPcmuFrameWithExtensions, rtp_len);
// In order to be able to run this test function multiple times we can not
// use the same sequence number twice. Increase the sequence number by one.
webrtc::SetBE16(reinterpret_cast<uint8_t*>(rtp_packet_data) + 2,
++sequence_number_);
- rtc::CopyOnWriteBuffer rtp_packet1to2(rtp_packet_data, rtp_len,
- packet_size);
- rtc::CopyOnWriteBuffer rtp_packet2to1(rtp_packet_data, rtp_len,
- packet_size);
+ webrtc::CopyOnWriteBuffer rtp_packet1to2(rtp_packet_data, rtp_len,
+ packet_size);
+ webrtc::CopyOnWriteBuffer rtp_packet2to1(rtp_packet_data, rtp_len,
+ packet_size);
char original_rtp_data[sizeof(kPcmuFrameWithExtensions)];
memcpy(original_rtp_data, rtp_packet_data, rtp_len);
- rtc::PacketOptions options;
+ webrtc::AsyncSocketPacketOptions options;
// Send a packet from `srtp_transport1_` to `srtp_transport2_` and verify
// that the packet can be successfully received and decrypted.
ASSERT_TRUE(dtls_srtp_transport1_->SendRtpPacket(&rtp_packet1to2, options,
- cricket::PF_SRTP_BYPASS));
+ webrtc::PF_SRTP_BYPASS));
ASSERT_TRUE(transport_observer2_.last_recv_rtp_packet().data());
EXPECT_EQ(0, memcmp(transport_observer2_.last_recv_rtp_packet().data(),
original_rtp_data, rtp_len));
@@ -237,7 +239,7 @@
// Do the same thing in the opposite direction.
ASSERT_TRUE(dtls_srtp_transport2_->SendRtpPacket(&rtp_packet2to1, options,
- cricket::PF_SRTP_BYPASS));
+ webrtc::PF_SRTP_BYPASS));
ASSERT_TRUE(transport_observer1_.last_recv_rtp_packet().data());
EXPECT_EQ(0, memcmp(transport_observer1_.last_recv_rtp_packet().data(),
original_rtp_data, rtp_len));
@@ -560,11 +562,12 @@
// Sending some RTCP packets.
size_t rtcp_len = sizeof(kRtcpReport);
size_t packet_size = rtcp_len + 4 + kRtpAuthTagLen;
- rtc::Buffer rtcp_packet_buffer(packet_size);
- rtc::CopyOnWriteBuffer rtcp_packet(kRtcpReport, rtcp_len, packet_size);
+ webrtc::Buffer rtcp_packet_buffer(packet_size);
+ webrtc::CopyOnWriteBuffer rtcp_packet(kRtcpReport, rtcp_len, packet_size);
int prev_received_packets = transport_observer2_.rtcp_count();
ASSERT_TRUE(dtls_srtp_transport1_->SendRtcpPacket(
- &rtcp_packet, rtc::PacketOptions(), cricket::PF_SRTP_BYPASS));
+ &rtcp_packet, webrtc::AsyncSocketPacketOptions(),
+ webrtc::PF_SRTP_BYPASS));
// The RTCP packet is not exepected to be received because the SRTP parameters
// are only reset on one side and the SRTCP index is out of sync.
EXPECT_EQ(prev_received_packets, transport_observer2_.rtcp_count());
diff --git a/pc/dtls_transport.cc b/pc/dtls_transport.cc
index 3b78320..f79f1bb 100644
--- a/pc/dtls_transport.cc
+++ b/pc/dtls_transport.cc
@@ -34,12 +34,11 @@
: owner_thread_(Thread::Current()),
info_(DtlsTransportState::kNew),
internal_dtls_transport_(std::move(internal)),
- ice_transport_(rtc::make_ref_counted<IceTransportWithPointer>(
+ ice_transport_(make_ref_counted<IceTransportWithPointer>(
internal_dtls_transport_->ice_transport())) {
RTC_DCHECK(internal_dtls_transport_.get());
internal_dtls_transport_->SubscribeDtlsTransportState(
- [this](cricket::DtlsTransportInternal* transport,
- DtlsTransportState state) {
+ [this](DtlsTransportInternal* transport, DtlsTransportState state) {
OnInternalDtlsState(transport, state);
});
UpdateInformation();
@@ -77,7 +76,7 @@
observer_ = nullptr;
}
-rtc::scoped_refptr<IceTransportInterface> DtlsTransport::ice_transport() {
+scoped_refptr<IceTransportInterface> DtlsTransport::ice_transport() {
return ice_transport_;
}
diff --git a/pc/dtls_transport.h b/pc/dtls_transport.h
index cf21c18..0ddc573 100644
--- a/pc/dtls_transport.h
+++ b/pc/dtls_transport.h
@@ -28,18 +28,18 @@
class IceTransportWithPointer;
-// This implementation wraps a cricket::DtlsTransport, and takes
+// This implementation wraps a webrtc::DtlsTransportInternalImpl, and takes
// ownership of it.
class DtlsTransport : public DtlsTransportInterface {
public:
// This object must be constructed and updated on a consistent thread,
- // the same thread as the one the cricket::DtlsTransportInternal object
+ // the same thread as the one the webrtc::DtlsTransportInternal object
// lives on.
// The Information() function can be called from a different thread,
// such as the signalling thread.
explicit DtlsTransport(std::unique_ptr<DtlsTransportInternal> internal);
- rtc::scoped_refptr<IceTransportInterface> ice_transport() override;
+ scoped_refptr<IceTransportInterface> ice_transport() override;
// Currently called from the signaling thread and potentially Chromium's
// JS thread.
@@ -80,7 +80,7 @@
DtlsTransportInformation info_ RTC_GUARDED_BY(lock_);
std::unique_ptr<DtlsTransportInternal> internal_dtls_transport_
RTC_GUARDED_BY(owner_thread_);
- const rtc::scoped_refptr<IceTransportWithPointer> ice_transport_;
+ const scoped_refptr<IceTransportWithPointer> ice_transport_;
};
} // namespace webrtc
diff --git a/pc/dtls_transport_unittest.cc b/pc/dtls_transport_unittest.cc
index 1b3e806..4769756 100644
--- a/pc/dtls_transport_unittest.cc
+++ b/pc/dtls_transport_unittest.cc
@@ -71,8 +71,7 @@
cricket_transport->SetRemoteSSLCertificate(certificate);
}
cricket_transport->SetSslCipherSuite(kNonsenseCipherSuite);
- transport_ =
- rtc::make_ref_counted<DtlsTransport>(std::move(cricket_transport));
+ transport_ = make_ref_counted<DtlsTransport>(std::move(cricket_transport));
}
void CompleteDtlsHandshake() {
@@ -89,7 +88,7 @@
}
AutoThread main_thread_;
- rtc::scoped_refptr<DtlsTransport> transport_;
+ scoped_refptr<DtlsTransport> transport_;
TestDtlsTransportObserver observer_;
};
@@ -97,7 +96,7 @@
auto cricket_transport =
std::make_unique<FakeDtlsTransport>("audio", ICE_CANDIDATE_COMPONENT_RTP);
auto webrtc_transport =
- rtc::make_ref_counted<DtlsTransport>(std::move(cricket_transport));
+ make_ref_counted<DtlsTransport>(std::move(cricket_transport));
ASSERT_TRUE(webrtc_transport->internal());
ASSERT_EQ(DtlsTransportState::kNew, webrtc_transport->Information().state());
webrtc_transport->Clear();
diff --git a/pc/dtmf_sender.cc b/pc/dtmf_sender.cc
index c1fba6e..6ecc285 100644
--- a/pc/dtmf_sender.cc
+++ b/pc/dtmf_sender.cc
@@ -64,13 +64,12 @@
return true;
}
-rtc::scoped_refptr<DtmfSender> DtmfSender::Create(
- TaskQueueBase* signaling_thread,
- DtmfProviderInterface* provider) {
+scoped_refptr<DtmfSender> DtmfSender::Create(TaskQueueBase* signaling_thread,
+ DtmfProviderInterface* provider) {
if (!signaling_thread) {
return nullptr;
}
- return rtc::make_ref_counted<DtmfSender>(signaling_thread, provider);
+ return make_ref_counted<DtmfSender>(signaling_thread, provider);
}
DtmfSender::DtmfSender(TaskQueueBase* signaling_thread,
diff --git a/pc/dtmf_sender.h b/pc/dtmf_sender.h
index ecdb499..5c75750 100644
--- a/pc/dtmf_sender.h
+++ b/pc/dtmf_sender.h
@@ -47,8 +47,8 @@
class DtmfSender : public DtmfSenderInterface {
public:
- static rtc::scoped_refptr<DtmfSender> Create(TaskQueueBase* signaling_thread,
- DtmfProviderInterface* provider);
+ static scoped_refptr<DtmfSender> Create(TaskQueueBase* signaling_thread,
+ DtmfProviderInterface* provider);
void OnDtmfProviderDestroyed();
@@ -91,7 +91,7 @@
int comma_delay_ RTC_GUARDED_BY(signaling_thread_);
// For cancelling the tasks which feed the DTMF provider one tone at a time.
- rtc::scoped_refptr<PendingTaskSafetyFlag> safety_flag_ RTC_GUARDED_BY(
+ scoped_refptr<PendingTaskSafetyFlag> safety_flag_ RTC_GUARDED_BY(
signaling_thread_) RTC_PT_GUARDED_BY(signaling_thread_) = nullptr;
};
diff --git a/pc/dtmf_sender_unittest.cc b/pc/dtmf_sender_unittest.cc
index c7ffa2f..d121809 100644
--- a/pc/dtmf_sender_unittest.cc
+++ b/pc/dtmf_sender_unittest.cc
@@ -89,7 +89,7 @@
bool InsertDtmf(int code, int duration) override {
int gap = 0;
- // TODO(ronghuawu): Make the timer (basically the rtc::TimeNanos)
+ // TODO(ronghuawu): Make the timer (basically the webrtc::TimeNanos)
// mockable and use a fake timer in the unit tests.
if (last_insert_dtmf_call_ > 0) {
gap = static_cast<int>(webrtc::TimeMillis() - last_insert_dtmf_call_);
@@ -217,7 +217,7 @@
webrtc::AutoThread main_thread_;
std::unique_ptr<FakeDtmfObserver> observer_;
std::unique_ptr<FakeDtmfProvider> provider_;
- rtc::scoped_refptr<DtmfSender> dtmf_;
+ webrtc::scoped_refptr<DtmfSender> dtmf_;
webrtc::ScopedFakeClock fake_clock_;
};
diff --git a/pc/external_hmac.cc b/pc/external_hmac.cc
index 3b72e26..6ee917d 100644
--- a/pc/external_hmac.cc
+++ b/pc/external_hmac.cc
@@ -93,7 +93,8 @@
}
srtp_err_status_t external_hmac_dealloc(srtp_auth_t* a) {
- rtc::ExplicitZeroMemory(a, sizeof(ExternalHmacContext) + sizeof(srtp_auth_t));
+ webrtc::ExplicitZeroMemory(a,
+ sizeof(ExternalHmacContext) + sizeof(srtp_auth_t));
// Free memory
delete[] a;
diff --git a/pc/g3doc/dtls_transport.md b/pc/g3doc/dtls_transport.md
index 28d6739..b567338 100644
--- a/pc/g3doc/dtls_transport.md
+++ b/pc/g3doc/dtls_transport.md
@@ -23,17 +23,17 @@
## webrtc::DtlsTransport
The [`webrtc::DtlsTransport`][1] class is a wrapper around the
-`cricket::DtlsTransportInternal` and allows registering observers implementing
+`webrtc::DtlsTransportInternal` and allows registering observers implementing
the `webrtc::DtlsTransportObserverInterface`. The
[`webrtc::DtlsTransportObserverInterface`][2] will provide updates to the
observers, passing around a snapshot of the transports state such as the
connection state, the remote certificate(s) and the SRTP ciphers as
[`DtlsTransportInformation`][3].
-## cricket::DtlsTransportInternal
+## webrtc::DtlsTransportInternal
-The [`cricket::DtlsTransportInternal`][4] class is an interface. Its
-implementation is [`cricket::DtlsTransport`][5]. The `cricket::DtlsTransport`
+The [`webrtc::DtlsTransportInternal`][4] class is an interface. Its
+implementation is [`webrtc::DtlsTransportInternalImpl`][5]. The `webrtc::DtlsTransportInternalImpl`
sends and receives network packets via an ICE transport. It also demultiplexes
DTLS packets and SRTP packets according to the scheme described in
[RFC 5764](https://tools.ietf.org/html/rfc5764#section-5.1.2).
@@ -42,7 +42,7 @@
The [`webrtc::DtlsSrtpTransport`][6] class is responsÑ–ble for extracting the
SRTP keys after the DTLS handshake as well as protection and unprotection of
-SRTP packets via its [`cricket::SrtpSession`][7].
+SRTP packets via its [`webrtc::SrtpSession`][7].
[1]: https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/pc/dtls_transport.h;l=32;drc=6a55e7307b78edb50f94a1ff1ef8393d58218369
[2]: https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/api/dtls_transport_interface.h;l=76;drc=34437d5660a80393d631657329ef74c6538be25a
diff --git a/pc/g3doc/peer_connection.md b/pc/g3doc/peer_connection.md
index cd01265..255def1 100644
--- a/pc/g3doc/peer_connection.md
+++ b/pc/g3doc/peer_connection.md
@@ -53,7 +53,7 @@
PeerConnectionFactory owns an object called ConnectionContext, and a
reference to this is passed to each PeerConnection. It is referenced
-via an rtc::scoped_refptr, which means that it is guaranteed to be
+via an webrtc::scoped_refptr, which means that it is guaranteed to be
alive as long as either the factory or one of the PeerConnections
is using it.
diff --git a/pc/g3doc/sctp_transport.md b/pc/g3doc/sctp_transport.md
index 100eb92..8d4979e 100644
--- a/pc/g3doc/sctp_transport.md
+++ b/pc/g3doc/sctp_transport.md
@@ -18,16 +18,16 @@
set during PeerConnectionFactory initialization).
The implementation of this object lives in pc/sctp_transport.{h,cc}, and is
-basically a wrapper around a `cricket::SctpTransportInternal`, hiding its
+basically a wrapper around a `webrtc::SctpTransportInternal`, hiding its
implementation details and APIs that shouldn't be accessed from the user.
The `webrtc::SctpTransport` is a ref counted object; it should be regarded
as owned by the PeerConnection, and will be closed when the PeerConnection
closes, but the object itself may survive longer than the PeerConnection.
-## cricket::SctpTransportInternal
+## webrtc::SctpTransportInternal
-[`cricket::SctpTransportInternal`](https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/media/sctp/sctp_transport_internal.h?q=cricket::SctpTransportInternal) owns two objects: The SCTP association object
+[`webrtc::SctpTransportInternal`](https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/media/sctp/sctp_transport_internal.h?q=webrtc::SctpTransportInternal) owns two objects: The SCTP association object
and the DTLS transport, which is the object used to send and receive messages
as emitted from or consumed by the sctp library.
diff --git a/pc/g3doc/srtp.md b/pc/g3doc/srtp.md
index 96bc55e..cdc1311 100644
--- a/pc/g3doc/srtp.md
+++ b/pc/g3doc/srtp.md
@@ -31,9 +31,9 @@
The cipher suite ordering allows a non-WebRTC peer to prefer GCM cipher suites,
however they are not selected as default by two instances of the WebRTC library.
-## cricket::SrtpSession
+## webrtc::SrtpSession
-The [`cricket::SrtpSession`][3] is providing encryption and decryption of SRTP
+The [`webrtc::SrtpSession`][3] is providing encryption and decryption of SRTP
packets using [`libsrtp`](https://github.com/cisco/libsrtp). Keys will be
provided by `SrtpTransport` or `DtlsSrtpTransport` in the [`SetSend`][4] and
[`SetRecv`][5] methods.
diff --git a/pc/ice_server_parsing.cc b/pc/ice_server_parsing.cc
index 7f98a64..02612eb 100644
--- a/pc/ice_server_parsing.cc
+++ b/pc/ice_server_parsing.cc
@@ -165,7 +165,7 @@
// by parsing `url` and using the username/password in `server`.
RTCError ParseIceServerUrl(const PeerConnectionInterface::IceServer& server,
absl::string_view url,
- cricket::ServerAddresses* stun_servers,
+ ServerAddresses* stun_servers,
std::vector<RelayServerConfig>* turn_servers) {
// RFC 7064
// stunURI = scheme ":" host [ ":" port ]
@@ -323,7 +323,7 @@
RTCError ParseIceServersOrError(
const PeerConnectionInterface::IceServers& servers,
- cricket::ServerAddresses* stun_servers,
+ ServerAddresses* stun_servers,
std::vector<RelayServerConfig>* turn_servers) {
for (const PeerConnectionInterface::IceServer& server : servers) {
if (!server.urls.empty()) {
@@ -356,7 +356,7 @@
RTCError ParseAndValidateIceServersFromConfiguration(
const PeerConnectionInterface::RTCConfiguration& configuration,
- cricket::ServerAddresses& stun_servers,
+ ServerAddresses& stun_servers,
std::vector<RelayServerConfig>& turn_servers) {
RTC_DCHECK(stun_servers.empty());
RTC_DCHECK(turn_servers.empty());
@@ -376,7 +376,7 @@
}
// Add the turn logging id to all turn servers
- for (cricket::RelayServerConfig& turn_server : turn_servers) {
+ for (RelayServerConfig& turn_server : turn_servers) {
turn_server.turn_logging_id = configuration.turn_logging_id;
}
diff --git a/pc/ice_server_parsing.h b/pc/ice_server_parsing.h
index 8009cb7..75c16f0 100644
--- a/pc/ice_server_parsing.h
+++ b/pc/ice_server_parsing.h
@@ -29,14 +29,14 @@
// PeerConnection through RTCConfiguration.
RTC_EXPORT RTCError
ParseIceServersOrError(const PeerConnectionInterface::IceServers& servers,
- cricket::ServerAddresses* stun_servers,
+ ServerAddresses* stun_servers,
std::vector<RelayServerConfig>* turn_servers);
// Calls `ParseIceServersOrError` to extract ice server information from the
// `configuration` and then validates the extracted configuration.
RTC_EXPORT RTCError ParseAndValidateIceServersFromConfiguration(
const PeerConnectionInterface::RTCConfiguration& configuration,
- cricket::ServerAddresses& stun_servers,
+ ServerAddresses& stun_servers,
std::vector<RelayServerConfig>& turn_servers);
} // namespace webrtc
diff --git a/pc/ice_server_parsing_unittest.cc b/pc/ice_server_parsing_unittest.cc
index c2deb51..df459e6 100644
--- a/pc/ice_server_parsing_unittest.cc
+++ b/pc/ice_server_parsing_unittest.cc
@@ -69,7 +69,7 @@
}
protected:
- cricket::ServerAddresses stun_servers_;
+ ServerAddresses stun_servers_;
std::vector<RelayServerConfig> turn_servers_;
};
@@ -86,12 +86,12 @@
EXPECT_TRUE(ParseTurnUrl("turn:hostname"));
EXPECT_EQ(0U, stun_servers_.size());
EXPECT_EQ(1U, turn_servers_.size());
- EXPECT_EQ(cricket::PROTO_UDP, turn_servers_[0].ports[0].proto);
+ EXPECT_EQ(PROTO_UDP, turn_servers_[0].ports[0].proto);
EXPECT_TRUE(ParseTurnUrl("turns:hostname"));
EXPECT_EQ(0U, stun_servers_.size());
EXPECT_EQ(1U, turn_servers_.size());
- EXPECT_EQ(cricket::PROTO_TLS, turn_servers_[0].ports[0].proto);
+ EXPECT_EQ(PROTO_TLS, turn_servers_[0].ports[0].proto);
EXPECT_TRUE(turn_servers_[0].tls_cert_policy ==
TlsCertPolicy::TLS_CERT_POLICY_SECURE);
@@ -102,7 +102,7 @@
EXPECT_EQ(1U, turn_servers_.size());
EXPECT_TRUE(turn_servers_[0].tls_cert_policy ==
TlsCertPolicy::TLS_CERT_POLICY_INSECURE_NO_CHECK);
- EXPECT_EQ(cricket::PROTO_TLS, turn_servers_[0].ports[0].proto);
+ EXPECT_EQ(PROTO_TLS, turn_servers_[0].ports[0].proto);
// invalid prefixes
EXPECT_FALSE(ParseUrl("stunn:hostname"));
@@ -116,13 +116,13 @@
EXPECT_TRUE(ParseTurnUrl("turns:hostname"));
EXPECT_EQ(1U, turn_servers_.size());
EXPECT_EQ(5349, turn_servers_[0].ports[0].address.port());
- EXPECT_EQ(cricket::PROTO_TLS, turn_servers_[0].ports[0].proto);
+ EXPECT_EQ(PROTO_TLS, turn_servers_[0].ports[0].proto);
// TURN defaults
EXPECT_TRUE(ParseTurnUrl("turn:hostname"));
EXPECT_EQ(1U, turn_servers_.size());
EXPECT_EQ(3478, turn_servers_[0].ports[0].address.port());
- EXPECT_EQ(cricket::PROTO_UDP, turn_servers_[0].ports[0].proto);
+ EXPECT_EQ(PROTO_UDP, turn_servers_[0].ports[0].proto);
// STUN defaults
EXPECT_TRUE(ParseUrl("stun:hostname"));
@@ -197,11 +197,11 @@
TEST_F(IceServerParsingTest, ParseTransport) {
EXPECT_TRUE(ParseTurnUrl("turn:hostname:1234?transport=tcp"));
EXPECT_EQ(1U, turn_servers_.size());
- EXPECT_EQ(cricket::PROTO_TCP, turn_servers_[0].ports[0].proto);
+ EXPECT_EQ(PROTO_TCP, turn_servers_[0].ports[0].proto);
EXPECT_TRUE(ParseTurnUrl("turn:hostname?transport=udp"));
EXPECT_EQ(1U, turn_servers_.size());
- EXPECT_EQ(cricket::PROTO_UDP, turn_servers_[0].ports[0].proto);
+ EXPECT_EQ(PROTO_UDP, turn_servers_[0].ports[0].proto);
EXPECT_FALSE(ParseTurnUrl("turn:hostname?transport=invalid"));
EXPECT_FALSE(ParseTurnUrl("turn:hostname?transport="));
diff --git a/pc/ice_transport_unittest.cc b/pc/ice_transport_unittest.cc
index 56abb7c..767d1ad 100644
--- a/pc/ice_transport_unittest.cc
+++ b/pc/ice_transport_unittest.cc
@@ -44,7 +44,7 @@
auto cricket_transport =
std::make_unique<FakeIceTransport>("name", 0, nullptr);
auto ice_transport =
- rtc::make_ref_counted<IceTransportWithPointer>(cricket_transport.get());
+ make_ref_counted<IceTransportWithPointer>(cricket_transport.get());
EXPECT_EQ(ice_transport->internal(), cricket_transport.get());
ice_transport->Clear();
EXPECT_NE(ice_transport->internal(), cricket_transport.get());
diff --git a/pc/jitter_buffer_delay.cc b/pc/jitter_buffer_delay.cc
index 3e0f500..7e8c3a5 100644
--- a/pc/jitter_buffer_delay.cc
+++ b/pc/jitter_buffer_delay.cc
@@ -30,9 +30,9 @@
int JitterBufferDelay::GetMs() const {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
- return SafeClamp(rtc::saturated_cast<int>(
- cached_delay_seconds_.value_or(kDefaultDelay) * 1000),
- 0, kMaximumDelayMs);
+ return SafeClamp(
+ saturated_cast<int>(cached_delay_seconds_.value_or(kDefaultDelay) * 1000),
+ 0, kMaximumDelayMs);
}
} // namespace webrtc
diff --git a/pc/jsep_session_description.cc b/pc/jsep_session_description.cc
index 8bdeeb6..fe4bd79 100644
--- a/pc/jsep_session_description.cc
+++ b/pc/jsep_session_description.cc
@@ -34,7 +34,7 @@
#include "rtc_base/net_helpers.h"
#include "rtc_base/socket_address.h"
-using cricket::Candidate;
+using webrtc::Candidate;
using ::webrtc::SessionDescription;
namespace webrtc {
diff --git a/pc/jsep_transport.cc b/pc/jsep_transport.cc
index e44df56f..8f0a397 100644
--- a/pc/jsep_transport.cc
+++ b/pc/jsep_transport.cc
@@ -110,16 +110,16 @@
unencrypted_rtp_transport_(std::move(unencrypted_rtp_transport)),
sdes_transport_(std::move(sdes_transport)),
dtls_srtp_transport_(std::move(dtls_srtp_transport)),
- rtp_dtls_transport_(rtp_dtls_transport
- ? rtc::make_ref_counted<DtlsTransport>(
- std::move(rtp_dtls_transport))
- : nullptr),
- rtcp_dtls_transport_(rtcp_dtls_transport
- ? rtc::make_ref_counted<DtlsTransport>(
- std::move(rtcp_dtls_transport))
- : nullptr),
+ rtp_dtls_transport_(
+ rtp_dtls_transport
+ ? make_ref_counted<DtlsTransport>(std::move(rtp_dtls_transport))
+ : nullptr),
+ rtcp_dtls_transport_(
+ rtcp_dtls_transport
+ ? make_ref_counted<DtlsTransport>(std::move(rtcp_dtls_transport))
+ : nullptr),
sctp_transport_(sctp_transport
- ? rtc::make_ref_counted<::webrtc::SctpTransport>(
+ ? make_ref_counted<::webrtc::SctpTransport>(
std::move(sctp_transport),
rtp_dtls_transport_)
: nullptr),
@@ -300,7 +300,7 @@
"not set.");
}
- for (const cricket::Candidate& candidate : candidates) {
+ for (const Candidate& candidate : candidates) {
auto transport = candidate.component() == ICE_CANDIDATE_COMPONENT_RTP
? rtp_dtls_transport_
: rtcp_dtls_transport_;
@@ -523,7 +523,7 @@
} else {
// We are not doing DTLS
remote_fingerprint =
- std::make_unique<SSLFingerprint>("", rtc::ArrayView<const uint8_t>());
+ std::make_unique<SSLFingerprint>("", ArrayView<const uint8_t>());
}
// Now that we have negotiated everything, push it downward.
// Note that we cache the result so that if we have race conditions
diff --git a/pc/jsep_transport_collection.cc b/pc/jsep_transport_collection.cc
index d475da6..c773b67 100644
--- a/pc/jsep_transport_collection.cc
+++ b/pc/jsep_transport_collection.cc
@@ -46,7 +46,7 @@
// groups.
bundle_groups_changed = true;
bundle_groups_.clear();
- for (const cricket::ContentGroup* new_bundle_group :
+ for (const ContentGroup* new_bundle_group :
description->GetGroupsByName(GROUP_TYPE_BUNDLE)) {
bundle_groups_.push_back(
std::make_unique<ContentGroup>(*new_bundle_group));
@@ -60,7 +60,7 @@
// Thus any m= sections added to a BUNDLE group in this offer can
// preemptively start using the bundled transport, as there is no possible
// non-bundled fallback.
- for (const cricket::ContentGroup* new_bundle_group :
+ for (const ContentGroup* new_bundle_group :
description->GetGroupsByName(GROUP_TYPE_BUNDLE)) {
// Attempt to find a matching existing group.
for (const std::string& mid : new_bundle_group->content_names()) {
@@ -106,11 +106,11 @@
// Remove the rejected content from the `bundle_group`.
// The const pointer arg is used to identify the group, we verify
// it before we use it to make a modification.
- auto bundle_group_it = std::find_if(
- bundle_groups_.begin(), bundle_groups_.end(),
- [bundle_group](std::unique_ptr<cricket::ContentGroup>& group) {
- return bundle_group == group.get();
- });
+ auto bundle_group_it =
+ std::find_if(bundle_groups_.begin(), bundle_groups_.end(),
+ [bundle_group](std::unique_ptr<ContentGroup>& group) {
+ return bundle_group == group.get();
+ });
RTC_DCHECK(bundle_group_it != bundle_groups_.end());
(*bundle_group_it)->RemoveContentName(mid);
established_bundle_groups_by_mid_.erase(
@@ -121,11 +121,11 @@
RTC_DCHECK_RUN_ON(&sequence_checker_);
RTC_DLOG(LS_VERBOSE) << "Deleting bundle group " << bundle_group->ToString();
- auto bundle_group_it = std::find_if(
- bundle_groups_.begin(), bundle_groups_.end(),
- [bundle_group](std::unique_ptr<cricket::ContentGroup>& group) {
- return bundle_group == group.get();
- });
+ auto bundle_group_it =
+ std::find_if(bundle_groups_.begin(), bundle_groups_.end(),
+ [bundle_group](std::unique_ptr<ContentGroup>& group) {
+ return bundle_group == group.get();
+ });
RTC_DCHECK(bundle_group_it != bundle_groups_.end());
auto mid_list = (*bundle_group_it)->content_names();
for (const auto& content_name : mid_list) {
diff --git a/pc/jsep_transport_controller.cc b/pc/jsep_transport_controller.cc
index aabbf58..7a6f7b6 100644
--- a/pc/jsep_transport_controller.cc
+++ b/pc/jsep_transport_controller.cc
@@ -84,7 +84,7 @@
port_allocator_(port_allocator),
async_dns_resolver_factory_(async_dns_resolver_factory),
transports_(
- [this](const std::string& mid, cricket::JsepTransport* transport) {
+ [this](const std::string& mid, JsepTransport* transport) {
return OnTransportChanged(mid, transport);
},
[this]() {
@@ -191,8 +191,8 @@
return jsep_transport->rtcp_dtls_transport();
}
-rtc::scoped_refptr<DtlsTransport>
-JsepTransportController::LookupDtlsTransportByMid(const std::string& mid) {
+scoped_refptr<DtlsTransport> JsepTransportController::LookupDtlsTransportByMid(
+ const std::string& mid) {
RTC_DCHECK_RUN_ON(network_thread_);
auto jsep_transport = GetJsepTransportForMid(mid);
if (!jsep_transport) {
@@ -201,7 +201,7 @@
return jsep_transport->RtpDtlsTransport();
}
-rtc::scoped_refptr<SctpTransport> JsepTransportController::GetSctpTransport(
+scoped_refptr<SctpTransport> JsepTransportController::GetSctpTransport(
const std::string& mid) const {
RTC_DCHECK_RUN_ON(network_thread_);
auto jsep_transport = GetJsepTransportForMid(mid);
@@ -323,7 +323,7 @@
}
bool JsepTransportController::SetLocalCertificate(
- const rtc::scoped_refptr<RTCCertificate>& certificate) {
+ const scoped_refptr<RTCCertificate>& certificate) {
if (!network_thread_->IsCurrent()) {
return network_thread_->BlockingCall(
[&] { return SetLocalCertificate(certificate); });
@@ -350,7 +350,7 @@
return true;
}
-rtc::scoped_refptr<RTCCertificate> JsepTransportController::GetLocalCertificate(
+scoped_refptr<RTCCertificate> JsepTransportController::GetLocalCertificate(
const std::string& transport_name) const {
RTC_DCHECK_RUN_ON(network_thread_);
@@ -393,7 +393,7 @@
RTCError JsepTransportController::AddRemoteCandidates(
const std::string& transport_name,
- const cricket::Candidates& candidates) {
+ const Candidates& candidates) {
RTC_DCHECK_RUN_ON(network_thread_);
RTC_DCHECK(VerifyCandidates(candidates).ok());
auto jsep_transport = GetJsepTransportByName(transport_name);
@@ -406,7 +406,7 @@
}
RTCError JsepTransportController::RemoveRemoteCandidates(
- const cricket::Candidates& candidates) {
+ const Candidates& candidates) {
if (!network_thread_->IsCurrent()) {
return network_thread_->BlockingCall(
[&] { return RemoveRemoteCandidates(candidates); });
@@ -420,8 +420,8 @@
return error;
}
- std::map<std::string, cricket::Candidates> candidates_by_transport_name;
- for (const cricket::Candidate& cand : candidates) {
+ std::map<std::string, Candidates> candidates_by_transport_name;
+ for (const Candidate& cand : candidates) {
if (!cand.transport_name().empty()) {
candidates_by_transport_name[cand.transport_name()].push_back(cand);
} else {
@@ -433,14 +433,14 @@
for (const auto& kv : candidates_by_transport_name) {
const std::string& transport_name = kv.first;
- const cricket::Candidates& transport_candidates = kv.second;
+ const Candidates& transport_candidates = kv.second;
JsepTransport* jsep_transport = GetJsepTransportByName(transport_name);
if (!jsep_transport) {
RTC_LOG(LS_WARNING)
<< "Not removing candidate because the JsepTransport doesn't exist.";
continue;
}
- for (const cricket::Candidate& candidate : transport_candidates) {
+ for (const Candidate& candidate : transport_candidates) {
DtlsTransportInternal* dtls =
candidate.component() == ICE_CANDIDATE_COMPONENT_RTP
? jsep_transport->rtp_dtls_transport()
@@ -490,7 +490,7 @@
return RTCError::OK();
}
-rtc::scoped_refptr<IceTransportInterface>
+scoped_refptr<IceTransportInterface>
JsepTransportController::CreateIceTransport(const std::string& transport_name,
bool rtcp) {
int component =
@@ -520,9 +520,9 @@
dtls = config_.dtls_transport_factory->CreateDtlsTransport(
ice, config_.crypto_options, config_.ssl_max_version);
} else {
- dtls = std::make_unique<cricket::DtlsTransport>(ice, config_.crypto_options,
- config_.event_log,
- config_.ssl_max_version);
+ dtls = std::make_unique<DtlsTransportInternalImpl>(
+ ice, config_.crypto_options, config_.event_log,
+ config_.ssl_max_version);
}
RTC_DCHECK(dtls);
@@ -539,21 +539,20 @@
dtls->SignalReceivingState.connect(
this, &JsepTransportController::OnTransportReceivingState_n);
dtls->ice_transport()->AddGatheringStateCallback(
- this, [this](cricket::IceTransportInternal* transport) {
+ this, [this](IceTransportInternal* transport) {
RTC_DCHECK_RUN_ON(network_thread_);
OnTransportGatheringState_n(transport);
});
dtls->ice_transport()->SignalCandidateGathered.connect(
this, &JsepTransportController::OnTransportCandidateGathered_n);
dtls->ice_transport()->SetCandidateErrorCallback(
- [this](cricket::IceTransportInternal* transport,
- const cricket::IceCandidateErrorEvent& error) {
+ [this](IceTransportInternal* transport,
+ const IceCandidateErrorEvent& error) {
RTC_DCHECK_RUN_ON(network_thread_);
OnTransportCandidateError_n(transport, error);
});
dtls->ice_transport()->SetCandidatesRemovedCallback(
- [this](cricket::IceTransportInternal* transport,
- const cricket::Candidates& candidates) {
+ [this](IceTransportInternal* transport, const Candidates& candidates) {
RTC_DCHECK_RUN_ON(network_thread_);
OnTransportCandidatesRemoved_n(transport, candidates);
});
@@ -564,13 +563,13 @@
dtls->ice_transport()->SignalIceTransportStateChanged.connect(
this, &JsepTransportController::OnTransportStateChanged_n);
dtls->ice_transport()->SetCandidatePairChangeCallback(
- [this](const cricket::CandidatePairChangeEvent& event) {
+ [this](const CandidatePairChangeEvent& event) {
RTC_DCHECK_RUN_ON(network_thread_);
OnTransportCandidatePairChanged_n(event);
});
dtls->SubscribeDtlsHandshakeError(
- [this](rtc::SSLHandshakeError error) { OnDtlsHandshakeError(error); });
+ [this](SSLHandshakeError error) { OnDtlsHandshakeError(error); });
return dtls;
}
@@ -692,7 +691,7 @@
MergeEncryptedHeaderExtensionIdsForBundles(description);
}
- for (const cricket::ContentInfo& content_info : description->contents()) {
+ for (const ContentInfo& content_info : description->contents()) {
// Don't create transports for rejected m-lines and bundled m-lines.
if (content_info.rejected ||
!bundles_.IsFirstMidInGroup(content_info.mid())) {
@@ -805,7 +804,7 @@
description->GetGroupsByName(GROUP_TYPE_BUNDLE);
// Verify `new_bundle_groups`.
std::map<std::string, const ContentGroup*> new_bundle_groups_by_mid;
- for (const cricket::ContentGroup* new_bundle_group : new_bundle_groups) {
+ for (const ContentGroup* new_bundle_group : new_bundle_groups) {
for (const std::string& content_name : new_bundle_group->content_names()) {
// The BUNDLE group must not contain a MID that is a member of a different
// BUNDLE group, or that contains the same MID multiple times.
@@ -837,7 +836,7 @@
new_bundle_groups_by_existing_bundle_groups;
std::map<const ContentGroup*, const ContentGroup*>
existing_bundle_groups_by_new_bundle_groups;
- for (const cricket::ContentGroup* new_bundle_group : new_bundle_groups) {
+ for (const ContentGroup* new_bundle_group : new_bundle_groups) {
for (const std::string& mid : new_bundle_group->content_names()) {
ContentGroup* existing_bundle_group = bundles_.LookupGroupByMid(mid);
if (!existing_bundle_group) {
@@ -869,8 +868,7 @@
: local_desc->GetGroupsByName(GROUP_TYPE_BUNDLE);
std::map<std::string, const ContentGroup*> offered_bundle_groups_by_mid;
- for (const cricket::ContentGroup* offered_bundle_group :
- offered_bundle_groups) {
+ for (const ContentGroup* offered_bundle_group : offered_bundle_groups) {
for (const std::string& content_name :
offered_bundle_group->content_names()) {
offered_bundle_groups_by_mid[content_name] = offered_bundle_group;
@@ -879,7 +877,7 @@
std::map<const ContentGroup*, const ContentGroup*>
new_bundle_groups_by_offered_bundle_groups;
- for (const cricket::ContentGroup* new_bundle_group : new_bundle_groups) {
+ for (const ContentGroup* new_bundle_group : new_bundle_groups) {
if (!new_bundle_group->FirstContentName()) {
// Empty groups could be a subset of any group.
continue;
@@ -994,7 +992,7 @@
const ContentInfo& content_info) {
// If the content is rejected, let the
// BaseChannel/SctpTransport change the RtpTransport/DtlsTransport first,
- // then destroy the cricket::JsepTransport.
+ // then destroy the webrtc::JsepTransport.
ContentGroup* bundle_group = bundles_.LookupGroupByMid(content_info.mid());
if (bundle_group && !bundle_group->content_names().empty() &&
content_info.mid() == *bundle_group->FirstContentName()) {
@@ -1024,7 +1022,7 @@
RTC_DCHECK(jsep_transport);
// If the content is bundled, let the
// BaseChannel/SctpTransport change the RtpTransport/DtlsTransport first,
- // then destroy the cricket::JsepTransport.
+ // then destroy the webrtc::JsepTransport.
// TODO(bugs.webrtc.org/9719) For media transport this is far from ideal,
// because it means that we first create media transport and start
// connecting it, and then we destroy it. We will need to address it before
@@ -1081,7 +1079,7 @@
std::map<const ContentGroup*, std::vector<int>>
merged_encrypted_extension_ids_by_bundle;
// Union the encrypted header IDs in the group when bundle is enabled.
- for (const cricket::ContentInfo& content_info : description->contents()) {
+ for (const ContentInfo& content_info : description->contents()) {
auto group = bundles_.LookupGroupByMid(content_info.mid());
if (!group)
continue;
@@ -1156,7 +1154,7 @@
return RTCError::OK();
}
- rtc::scoped_refptr<IceTransportInterface> ice =
+ scoped_refptr<IceTransportInterface> ice =
CreateIceTransport(content_info.mid(), /*rtcp=*/false);
std::unique_ptr<DtlsTransportInternal> rtp_dtls_transport =
@@ -1167,7 +1165,7 @@
std::unique_ptr<SrtpTransport> sdes_transport;
std::unique_ptr<DtlsSrtpTransport> dtls_srtp_transport;
- rtc::scoped_refptr<IceTransportInterface> rtcp_ice;
+ scoped_refptr<IceTransportInterface> rtcp_ice;
if (config_.rtcp_mux_policy !=
PeerConnectionInterface::kRtcpMuxPolicyRequire &&
content_info.type == MediaProtocolType::kRtp) {
@@ -1208,7 +1206,7 @@
payload_type_picker_);
jsep_transport->rtp_transport()->SubscribeRtcpPacketReceived(
- this, [this](rtc::CopyOnWriteBuffer* buffer, int64_t packet_time_ms) {
+ this, [this](CopyOnWriteBuffer* buffer, int64_t packet_time_ms) {
RTC_DCHECK_RUN_ON(network_thread_);
OnRtcpPacketReceived_n(buffer, packet_time_ms);
});
@@ -1257,7 +1255,7 @@
ice_role = ICEROLE_CONTROLLING;
}
} else {
- // If our role is cricket::ICEROLE_CONTROLLED and the remote endpoint
+ // If our role is webrtc::ICEROLE_CONTROLLED and the remote endpoint
// supports only ice_lite, this local endpoint should take the CONTROLLING
// role.
// TODO(deadbeef): This is a session-level attribute, so it really shouldn't
@@ -1318,7 +1316,7 @@
}
void JsepTransportController::OnTransportCandidatesRemoved_n(
IceTransportInternal* transport,
- const cricket::Candidates& candidates) {
+ const Candidates& candidates) {
signal_ice_candidates_removed_.Send(candidates);
}
void JsepTransportController::OnTransportCandidatePairChanged_n(
@@ -1352,8 +1350,7 @@
void JsepTransportController::UpdateAggregateStates_n() {
TRACE_EVENT0("webrtc", "JsepTransportController::UpdateAggregateStates_n");
auto dtls_transports = GetActiveDtlsTransports();
- cricket::IceConnectionState new_connection_state =
- cricket::kIceConnectionConnecting;
+ IceConnectionState new_connection_state = kIceConnectionConnecting;
PeerConnectionInterface::IceConnectionState new_ice_connection_state =
PeerConnectionInterface::IceConnectionState::kIceConnectionNew;
PeerConnectionInterface::PeerConnectionState new_combined_state =
@@ -1370,12 +1367,12 @@
for (const auto& dtls : dtls_transports) {
any_failed = any_failed || dtls->ice_transport()->GetState() ==
- cricket::IceTransportState::STATE_FAILED;
+ IceTransportStateInternal::STATE_FAILED;
all_connected = all_connected && dtls->writable();
all_completed =
all_completed && dtls->writable() &&
dtls->ice_transport()->GetState() ==
- cricket::IceTransportState::STATE_COMPLETED &&
+ IceTransportStateInternal::STATE_COMPLETED &&
dtls->ice_transport()->GetIceRole() == ICEROLE_CONTROLLING &&
dtls->ice_transport()->gathering_state() == kIceGatheringComplete;
any_gathering = any_gathering || dtls->ice_transport()->gathering_state() !=
@@ -1389,11 +1386,11 @@
}
if (any_failed) {
- new_connection_state = cricket::kIceConnectionFailed;
+ new_connection_state = kIceConnectionFailed;
} else if (all_completed) {
- new_connection_state = cricket::kIceConnectionCompleted;
+ new_connection_state = kIceConnectionCompleted;
} else if (all_connected) {
- new_connection_state = cricket::kIceConnectionConnected;
+ new_connection_state = kIceConnectionConnected;
}
if (ice_connection_state_ != new_connection_state) {
ice_connection_state_ = new_connection_state;
@@ -1525,9 +1522,8 @@
}
}
-void JsepTransportController::OnRtcpPacketReceived_n(
- rtc::CopyOnWriteBuffer* packet,
- int64_t packet_time_us) {
+void JsepTransportController::OnRtcpPacketReceived_n(CopyOnWriteBuffer* packet,
+ int64_t packet_time_us) {
RTC_DCHECK(config_.rtcp_handler);
config_.rtcp_handler(*packet, packet_time_us);
}
diff --git a/pc/jsep_transport_controller.h b/pc/jsep_transport_controller.h
index d4ea2cf..3f42a02 100644
--- a/pc/jsep_transport_controller.h
+++ b/pc/jsep_transport_controller.h
@@ -96,7 +96,7 @@
virtual bool OnTransportChanged(
const std::string& mid,
RtpTransportInternal* rtp_transport,
- rtc::scoped_refptr<DtlsTransport> dtls_transport,
+ scoped_refptr<DtlsTransport> dtls_transport,
DataChannelTransportInterface* data_channel_transport) = 0;
};
@@ -121,7 +121,7 @@
Observer* transport_observer = nullptr;
// Must be provided and valid for the lifetime of the
// JsepTransportController instance.
- absl::AnyInvocable<void(const rtc::CopyOnWriteBuffer& packet,
+ absl::AnyInvocable<void(const webrtc::CopyOnWriteBuffer& packet,
int64_t packet_time_us) const>
rtcp_handler;
absl::AnyInvocable<void(const RtpPacketReceived& parsed_packet) const>
@@ -182,10 +182,8 @@
const DtlsTransportInternal* GetRtcpDtlsTransport(
const std::string& mid) const;
// Gets the externally sharable version of the DtlsTransport.
- rtc::scoped_refptr<DtlsTransport> LookupDtlsTransportByMid(
- const std::string& mid);
- rtc::scoped_refptr<SctpTransport> GetSctpTransport(
- const std::string& mid) const;
+ scoped_refptr<DtlsTransport> LookupDtlsTransportByMid(const std::string& mid);
+ scoped_refptr<SctpTransport> GetSctpTransport(const std::string& mid) const;
DataChannelTransportInterface* GetDataChannelTransport(
const std::string& mid) const;
@@ -217,9 +215,8 @@
*********************/
// Specifies the identity to use in this session.
// Can only be called once.
- bool SetLocalCertificate(
- const rtc::scoped_refptr<RTCCertificate>& certificate);
- rtc::scoped_refptr<RTCCertificate> GetLocalCertificate(
+ bool SetLocalCertificate(const scoped_refptr<RTCCertificate>& certificate);
+ scoped_refptr<RTCCertificate> GetLocalCertificate(
const std::string& mid) const;
// Caller owns returned certificate chain. This method mainly exists for
// stats reporting.
@@ -249,14 +246,14 @@
RTCError RollbackTransports();
- // F: void(const std::string&, const std::vector<cricket::Candidate>&)
+ // F: void(const std::string&, const std::vector<webrtc::Candidate>&)
template <typename F>
void SubscribeIceCandidateGathered(F&& callback) {
RTC_DCHECK_RUN_ON(network_thread_);
signal_ice_candidates_gathered_.AddReceiver(std::forward<F>(callback));
}
- // F: void(cricket::IceConnectionState)
+ // F: void(webrtc::IceConnectionState)
template <typename F>
void SubscribeIceConnectionState(F&& callback) {
RTC_DCHECK_RUN_ON(network_thread_);
@@ -278,28 +275,28 @@
std::forward<F>(callback));
}
- // F: void(cricket::IceGatheringState)
+ // F: void(webrtc::IceGatheringState)
template <typename F>
void SubscribeIceGatheringState(F&& callback) {
RTC_DCHECK_RUN_ON(network_thread_);
signal_ice_gathering_state_.AddReceiver(std::forward<F>(callback));
}
- // F: void(const cricket::IceCandidateErrorEvent&)
+ // F: void(const webrtc::IceCandidateErrorEvent&)
template <typename F>
void SubscribeIceCandidateError(F&& callback) {
RTC_DCHECK_RUN_ON(network_thread_);
signal_ice_candidate_error_.AddReceiver(std::forward<F>(callback));
}
- // F: void(const std::vector<cricket::Candidate>&)
+ // F: void(const std::vector<webrtc::Candidate>&)
template <typename F>
void SubscribeIceCandidatesRemoved(F&& callback) {
RTC_DCHECK_RUN_ON(network_thread_);
signal_ice_candidates_removed_.AddReceiver(std::forward<F>(callback));
}
- // F: void(const cricket::CandidatePairChangeEvent&)
+ // F: void(const webrtc::CandidatePairChangeEvent&)
template <typename F>
void SubscribeIceCandidatePairChanged(F&& callback) {
RTC_DCHECK_RUN_ON(network_thread_);
@@ -313,7 +310,7 @@
// Else if all completed => completed,
// Else if all connected => connected,
// Else => connecting
- CallbackList<cricket::IceConnectionState> signal_ice_connection_state_
+ CallbackList<IceConnectionState> signal_ice_connection_state_
RTC_GUARDED_BY(network_thread_);
CallbackList<PeerConnectionInterface::PeerConnectionState>
@@ -420,7 +417,7 @@
std::unique_ptr<DtlsTransportInternal> CreateDtlsTransport(
const ContentInfo& content_info,
IceTransportInternal* ice);
- rtc::scoped_refptr<IceTransportInterface> CreateIceTransport(
+ scoped_refptr<IceTransportInterface> CreateIceTransport(
const std::string& transport_name,
bool rtcp);
@@ -460,7 +457,7 @@
const IceCandidateErrorEvent& event)
RTC_RUN_ON(network_thread_);
void OnTransportCandidatesRemoved_n(IceTransportInternal* transport,
- const cricket::Candidates& candidates)
+ const Candidates& candidates)
RTC_RUN_ON(network_thread_);
void OnTransportRoleConflict_n(IceTransportInternal* transport)
RTC_RUN_ON(network_thread_);
@@ -470,8 +467,7 @@
RTC_RUN_ON(network_thread_);
void UpdateAggregateStates_n() RTC_RUN_ON(network_thread_);
- void OnRtcpPacketReceived_n(rtc::CopyOnWriteBuffer* packet,
- int64_t packet_time_us)
+ void OnRtcpPacketReceived_n(CopyOnWriteBuffer* packet, int64_t packet_time_us)
RTC_RUN_ON(network_thread_);
void OnUnDemuxableRtpPacketReceived_n(const RtpPacketReceived& packet)
RTC_RUN_ON(network_thread_);
@@ -489,8 +485,7 @@
// Aggregate states for Transports.
// standardized_ice_connection_state_ is intended to replace
// ice_connection_state, see bugs.webrtc.org/9308
- cricket::IceConnectionState ice_connection_state_ =
- cricket::kIceConnectionConnecting;
+ IceConnectionState ice_connection_state_ = kIceConnectionConnecting;
PeerConnectionInterface::IceConnectionState
standardized_ice_connection_state_ =
PeerConnectionInterface::kIceConnectionNew;
@@ -505,7 +500,7 @@
IceConfig ice_config_;
IceRole ice_role_ = ICEROLE_CONTROLLING;
- rtc::scoped_refptr<RTCCertificate> certificate_;
+ scoped_refptr<RTCCertificate> certificate_;
BundleManager bundles_;
// Reference to the SdpOfferAnswerHandler's payload type picker.
diff --git a/pc/jsep_transport_controller_unittest.cc b/pc/jsep_transport_controller_unittest.cc
index 0ec608c..e8d8117 100644
--- a/pc/jsep_transport_controller_unittest.cc
+++ b/pc/jsep_transport_controller_unittest.cc
@@ -69,7 +69,7 @@
#include "test/scoped_key_value_config.h"
#include "test/wait_until.h"
-using cricket::Candidate;
+using webrtc::Candidate;
using ::webrtc::Candidates;
using ::webrtc::FakeDtlsTransport;
@@ -93,11 +93,11 @@
class FakeIceTransportFactory : public IceTransportFactory {
public:
~FakeIceTransportFactory() override = default;
- rtc::scoped_refptr<IceTransportInterface> CreateIceTransport(
+ scoped_refptr<IceTransportInterface> CreateIceTransport(
const std::string& transport_name,
int component,
IceTransportInit init) override {
- return rtc::make_ref_counted<FakeIceTransportWrapper>(
+ return make_ref_counted<FakeIceTransportWrapper>(
std::make_unique<FakeIceTransport>(transport_name, component));
}
};
@@ -128,13 +128,13 @@
Thread* network_thread = Thread::Current(),
PortAllocator* port_allocator = nullptr) {
config.transport_observer = this;
- config.rtcp_handler = [](const rtc::CopyOnWriteBuffer& packet,
+ config.rtcp_handler = [](const CopyOnWriteBuffer& packet,
int64_t packet_time_us) {
RTC_DCHECK_NOTREACHED();
};
config.ice_transport_factory = fake_ice_transport_factory_.get();
config.dtls_transport_factory = fake_dtls_transport_factory_.get();
- config.on_dtls_handshake_error_ = [](rtc::SSLHandshakeError s) {};
+ config.on_dtls_handshake_error_ = [](SSLHandshakeError s) {};
transport_controller_ = std::make_unique<JsepTransportController>(
env_, network_thread, port_allocator,
nullptr /* async_resolver_factory */, payload_type_picker_,
@@ -144,7 +144,7 @@
void ConnectTransportControllerSignals() {
transport_controller_->SubscribeIceConnectionState(
- [this](cricket::IceConnectionState s) {
+ [this](IceConnectionState s) {
JsepTransportControllerTest::OnConnectionState(s);
});
transport_controller_->SubscribeConnectionState(
@@ -156,12 +156,12 @@
JsepTransportControllerTest::OnStandardizedIceConnectionState(s);
});
transport_controller_->SubscribeIceGatheringState(
- [this](cricket::IceGatheringState s) {
+ [this](IceGatheringState s) {
JsepTransportControllerTest::OnGatheringState(s);
});
transport_controller_->SubscribeIceCandidateGathered(
[this](const std::string& transport,
- const std::vector<cricket::Candidate>& candidates) {
+ const std::vector<Candidate>& candidates) {
JsepTransportControllerTest::OnCandidatesGathered(transport,
candidates);
});
@@ -207,7 +207,7 @@
const std::string& pwd,
IceMode ice_mode,
ConnectionRole conn_role,
- rtc::scoped_refptr<RTCCertificate> cert) {
+ scoped_refptr<RTCCertificate> cert) {
std::unique_ptr<AudioContentDescription> audio(
new AudioContentDescription());
// Set RTCP-mux to be true because the default policy is "mux required".
@@ -223,7 +223,7 @@
const std::string& pwd,
IceMode ice_mode,
ConnectionRole conn_role,
- rtc::scoped_refptr<RTCCertificate> cert) {
+ scoped_refptr<RTCCertificate> cert) {
std::unique_ptr<VideoContentDescription> video(
new VideoContentDescription());
// Set RTCP-mux to be true because the default policy is "mux required".
@@ -240,7 +240,7 @@
const std::string& pwd,
IceMode ice_mode,
ConnectionRole conn_role,
- rtc::scoped_refptr<RTCCertificate> cert) {
+ scoped_refptr<RTCCertificate> cert) {
RTC_CHECK(protocol_type == MediaProtocolType::kSctp);
std::unique_ptr<SctpDataContentDescription> data(
new SctpDataContentDescription());
@@ -256,7 +256,7 @@
const std::string& pwd,
IceMode ice_mode,
ConnectionRole conn_role,
- rtc::scoped_refptr<RTCCertificate> cert) {
+ scoped_refptr<RTCCertificate> cert) {
std::unique_ptr<SSLFingerprint> fingerprint;
if (cert) {
fingerprint = SSLFingerprint::CreateFromCertificate(*cert);
@@ -324,7 +324,7 @@
}
protected:
- void OnConnectionState(cricket::IceConnectionState state) {
+ void OnConnectionState(IceConnectionState state) {
ice_signaled_on_thread_ = Thread::Current();
connection_state_ = state;
++connection_state_signal_count_;
@@ -364,7 +364,7 @@
bool OnTransportChanged(
const std::string& mid,
RtpTransportInternal* rtp_transport,
- rtc::scoped_refptr<DtlsTransport> dtls_transport,
+ scoped_refptr<DtlsTransport> dtls_transport,
DataChannelTransportInterface* data_channel_transport) override {
changed_rtp_transport_by_mid_[mid] = rtp_transport;
if (dtls_transport) {
@@ -379,8 +379,7 @@
Environment env_;
AutoThread main_thread_;
// Information received from signals from transport controller.
- cricket::IceConnectionState connection_state_ =
- cricket::kIceConnectionConnecting;
+ IceConnectionState connection_state_ = kIceConnectionConnecting;
PeerConnectionInterface::IceConnectionState ice_connection_state_ =
PeerConnectionInterface::kIceConnectionNew;
PeerConnectionInterface::PeerConnectionState combined_connection_state_ =
@@ -595,9 +594,9 @@
TEST_F(JsepTransportControllerTest, SetAndGetLocalCertificate) {
CreateJsepTransportController(JsepTransportController::Config());
- rtc::scoped_refptr<RTCCertificate> certificate1 =
+ scoped_refptr<RTCCertificate> certificate1 =
RTCCertificate::Create(SSLIdentity::Create("session1", KT_DEFAULT));
- rtc::scoped_refptr<RTCCertificate> returned_certificate;
+ scoped_refptr<RTCCertificate> returned_certificate;
auto description = std::make_unique<SessionDescription>();
AddAudioSection(description.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
@@ -619,7 +618,7 @@
EXPECT_EQ(nullptr, transport_controller_->GetLocalCertificate(kVideoMid1));
// Shouldn't be able to change the identity once set.
- rtc::scoped_refptr<RTCCertificate> certificate2 =
+ scoped_refptr<RTCCertificate> certificate2 =
RTCCertificate::Create(SSLIdentity::Create("session2", KT_DEFAULT));
EXPECT_FALSE(transport_controller_->SetLocalCertificate(certificate2));
}
@@ -710,7 +709,7 @@
fake_ice->SetConnectionCount(1);
// The connection stats will be failed if there is no active connection.
fake_ice->SetConnectionCount(0);
- EXPECT_THAT(WaitUntil([&] { return cricket::kIceConnectionFailed; },
+ EXPECT_THAT(WaitUntil([&] { return kIceConnectionFailed; },
::testing::Eq(connection_state_),
{.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
IsRtcOk());
@@ -755,7 +754,7 @@
fake_video_dtls->fake_ice_transport()->SetConnectionCount(0);
fake_video_dtls->fake_ice_transport()->SetCandidatesGatheringComplete();
- EXPECT_THAT(WaitUntil([&] { return cricket::kIceConnectionFailed; },
+ EXPECT_THAT(WaitUntil([&] { return kIceConnectionFailed; },
::testing::Eq(connection_state_),
{.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
IsRtcOk());
@@ -776,11 +775,11 @@
fake_audio_dtls->SetDtlsState(DtlsTransportState::kConnected);
fake_video_dtls->SetDtlsState(DtlsTransportState::kConnected);
- // Set the connection count to be 2 and the cricket::FakeIceTransport will set
+ // Set the connection count to be 2 and the webrtc::FakeIceTransport will set
// the transport state to be STATE_CONNECTING.
fake_video_dtls->fake_ice_transport()->SetConnectionCount(2);
fake_video_dtls->SetWritable(true);
- EXPECT_THAT(WaitUntil([&] { return cricket::kIceConnectionConnected; },
+ EXPECT_THAT(WaitUntil([&] { return kIceConnectionConnected; },
::testing::Eq(connection_state_),
{.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
IsRtcOk());
@@ -821,7 +820,7 @@
// We should only get a signal when all are connected.
fake_audio_dtls->fake_ice_transport()->SetTransportState(
IceTransportState::kCompleted,
- cricket::IceTransportState::STATE_COMPLETED);
+ IceTransportStateInternal::STATE_COMPLETED);
fake_audio_dtls->SetWritable(true);
fake_audio_dtls->fake_ice_transport()->SetCandidatesGatheringComplete();
@@ -842,10 +841,10 @@
EXPECT_EQ(1, combined_connection_state_signal_count_);
fake_video_dtls->fake_ice_transport()->SetTransportState(
- IceTransportState::kFailed, cricket::IceTransportState::STATE_FAILED);
+ IceTransportState::kFailed, IceTransportStateInternal::STATE_FAILED);
fake_video_dtls->fake_ice_transport()->SetCandidatesGatheringComplete();
- EXPECT_THAT(WaitUntil([&] { return cricket::kIceConnectionFailed; },
+ EXPECT_THAT(WaitUntil([&] { return kIceConnectionFailed; },
::testing::Eq(connection_state_),
{.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
IsRtcOk());
@@ -866,13 +865,13 @@
fake_audio_dtls->SetDtlsState(DtlsTransportState::kConnected);
fake_video_dtls->SetDtlsState(DtlsTransportState::kConnected);
- // Set the connection count to be 1 and the cricket::FakeIceTransport will set
+ // Set the connection count to be 1 and the webrtc::FakeIceTransport will set
// the transport state to be STATE_COMPLETED.
fake_video_dtls->fake_ice_transport()->SetTransportState(
IceTransportState::kCompleted,
- cricket::IceTransportState::STATE_COMPLETED);
+ IceTransportStateInternal::STATE_COMPLETED);
fake_video_dtls->SetWritable(true);
- EXPECT_THAT(WaitUntil([&] { return cricket::kIceConnectionCompleted; },
+ EXPECT_THAT(WaitUntil([&] { return kIceConnectionCompleted; },
::testing::Eq(connection_state_),
{.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
IsRtcOk());
@@ -997,7 +996,7 @@
fake_video_dtls = static_cast<FakeDtlsTransport*>(
transport_controller_->GetDtlsTransport(kVideoMid1));
EXPECT_EQ(fake_audio_dtls, fake_video_dtls);
- EXPECT_THAT(WaitUntil([&] { return cricket::kIceConnectionCompleted; },
+ EXPECT_THAT(WaitUntil([&] { return kIceConnectionCompleted; },
::testing::Eq(connection_state_),
{.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
IsRtcOk());
@@ -1036,7 +1035,7 @@
fake_audio_dtls->fake_ice_transport()->MaybeStartGathering();
fake_audio_dtls->fake_ice_transport()->SetTransportState(
IceTransportState::kChecking,
- cricket::IceTransportState::STATE_CONNECTING);
+ IceTransportStateInternal::STATE_CONNECTING);
EXPECT_THAT(
WaitUntil([&] { return PeerConnectionInterface::kIceConnectionChecking; },
::testing::Eq(ice_connection_state_),
@@ -1139,7 +1138,7 @@
CreateLocalDescriptionAndCompleteConnectionOnNetworkThread();
// connecting --> connected --> completed
- EXPECT_THAT(WaitUntil([&] { return cricket::kIceConnectionCompleted; },
+ EXPECT_THAT(WaitUntil([&] { return kIceConnectionCompleted; },
::testing::Eq(connection_state_),
{.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
IsRtcOk());
diff --git a/pc/jsep_transport_unittest.cc b/pc/jsep_transport_unittest.cc
index ad48071..ca4a064 100644
--- a/pc/jsep_transport_unittest.cc
+++ b/pc/jsep_transport_unittest.cc
@@ -96,7 +96,7 @@
return nullptr;
}
- return rtc::make_ref_counted<FakeIceTransportWrapper>(std::move(internal));
+ return make_ref_counted<FakeIceTransportWrapper>(std::move(internal));
}
class JsepTransport2Test : public ::testing::Test, public sigslot::has_slots<> {
@@ -1050,13 +1050,13 @@
static_cast<FakeDtlsTransport*>(jsep_transport2_->rtp_dtls_transport());
fake_dtls1->fake_ice_transport()->RegisterReceivedPacketCallback(
- this, [&](rtc::PacketTransportInternal* transport,
- const rtc::ReceivedPacket& packet) {
+ this, [&](PacketTransportInternal* transport,
+ const ReceivedIpPacket& packet) {
OnReadPacket1(transport, packet);
});
fake_dtls2->fake_ice_transport()->RegisterReceivedPacketCallback(
- this, [&](rtc::PacketTransportInternal* transport,
- const rtc::ReceivedPacket& packet) {
+ this, [&](PacketTransportInternal* transport,
+ const ReceivedIpPacket& packet) {
OnReadPacket2(transport, packet);
});
@@ -1069,7 +1069,7 @@
}
void OnReadPacket1(PacketTransportInternal* transport,
- const rtc::ReceivedPacket& packet) {
+ const ReceivedIpPacket& packet) {
RTC_LOG(LS_INFO) << "JsepTransport 1 Received a packet.";
CompareHeaderExtensions(
reinterpret_cast<const char*>(kPcmuFrameWithExtensions),
@@ -1080,7 +1080,7 @@
}
void OnReadPacket2(PacketTransportInternal* transport,
- const rtc::ReceivedPacket& packet) {
+ const ReceivedIpPacket& packet) {
RTC_LOG(LS_INFO) << "JsepTransport 2 Received a packet.";
CompareHeaderExtensions(
reinterpret_cast<const char*>(kPcmuFrameWithExtensions),
@@ -1127,7 +1127,7 @@
CopyOnWriteBuffer rtp_packet(rtp_packet_data, rtp_len, packet_size);
int packet_count_before = received_packet_count_;
- rtc::PacketOptions options;
+ AsyncSocketPacketOptions options;
// Send a packet and verify that the packet can be successfully received and
// decrypted.
ASSERT_TRUE(sender_transport->rtp_transport()->SendRtpPacket(
diff --git a/pc/legacy_stats_collector.cc b/pc/legacy_stats_collector.cc
index e99dd7c..87cc3eb 100644
--- a/pc/legacy_stats_collector.cc
+++ b/pc/legacy_stats_collector.cc
@@ -907,7 +907,7 @@
}
LegacyStatsCollector::SessionStats LegacyStatsCollector::ExtractSessionInfo_n(
- const std::vector<rtc::scoped_refptr<
+ const std::vector<scoped_refptr<
RtpTransceiverProxyWithInternal<RtpTransceiver>>>& transceivers,
std::optional<std::string> sctp_transport_name,
std::optional<std::string> sctp_mid) {
@@ -946,7 +946,7 @@
// same local and remote certificates.
//
StatsReport::Id local_cert_report_id, remote_cert_report_id;
- rtc::scoped_refptr<RTCCertificate> certificate;
+ scoped_refptr<RTCCertificate> certificate;
if (pc_->GetLocalCertificate(transport.name, &certificate)) {
transport.local_cert_stats =
certificate->GetSSLCertificateChain().GetStats();
@@ -973,7 +973,7 @@
report->AddBoolean(StatsReport::kStatsValueNameInitiator,
pc_->initial_offerer());
- for (const cricket::CandidateStats& stats : session_stats.candidate_stats) {
+ for (const CandidateStats& stats : session_stats.candidate_stats) {
AddCandidateReport(stats, true);
}
@@ -1029,13 +1029,13 @@
// AddConnectionInfoReport below, and they may report candidates that are
// not paired. Also, the candidate report generated in
// AddConnectionInfoReport do not report port stats like StunStats.
- for (const cricket::CandidateStats& stats :
+ for (const CandidateStats& stats :
channel_iter.ice_transport_stats.candidate_stats_list) {
AddCandidateReport(stats, true);
}
int connection_id = 0;
- for (const cricket::ConnectionInfo& info :
+ for (const ConnectionInfo& info :
channel_iter.ice_transport_stats.connection_infos) {
StatsReport* connection_report = AddConnectionInfoReport(
transport.name, channel_iter.component, connection_id++,
@@ -1296,7 +1296,7 @@
if (!sender->ssrc()) {
continue;
}
- const rtc::scoped_refptr<MediaStreamTrackInterface> track(sender->track());
+ const scoped_refptr<MediaStreamTrackInterface> track(sender->track());
if (!track || track->kind() != MediaStreamTrackInterface::kVideoKind) {
continue;
}
diff --git a/pc/legacy_stats_collector.h b/pc/legacy_stats_collector.h
index bc15ce8..e2786b1 100644
--- a/pc/legacy_stats_collector.h
+++ b/pc/legacy_stats_collector.h
@@ -136,7 +136,7 @@
SessionStats& operator=(SessionStats&&) = default;
SessionStats& operator=(SessionStats&) = delete;
- cricket::CandidateStatsList candidate_stats;
+ CandidateStatsList candidate_stats;
std::vector<TransportStats> transport_stats;
std::map<std::string, std::string> transport_names_by_mid;
};
@@ -188,7 +188,7 @@
void UpdateTrackReports();
SessionStats ExtractSessionInfo_n(
- const std::vector<rtc::scoped_refptr<
+ const std::vector<scoped_refptr<
RtpTransceiverProxyWithInternal<RtpTransceiver>>>& transceivers,
std::optional<std::string> sctp_transport_name,
std::optional<std::string> sctp_mid);
diff --git a/pc/legacy_stats_collector_unittest.cc b/pc/legacy_stats_collector_unittest.cc
index b20a98d..7ecc5bf 100644
--- a/pc/legacy_stats_collector_unittest.cc
+++ b/pc/legacy_stats_collector_unittest.cc
@@ -108,7 +108,7 @@
public:
explicit FakeAudioTrack(const std::string& id)
: MediaStreamTrack<AudioTrackInterface>(id),
- processor_(rtc::make_ref_counted<FakeAudioProcessor>()) {}
+ processor_(make_ref_counted<FakeAudioProcessor>()) {}
std::string kind() const override { return "audio"; }
AudioSourceInterface* GetSource() const override { return NULL; }
void AddSink(AudioTrackSinkInterface* sink) override {}
@@ -117,12 +117,12 @@
*level = 1;
return true;
}
- rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
+ scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
return processor_;
}
private:
- rtc::scoped_refptr<FakeAudioProcessor> processor_;
+ scoped_refptr<FakeAudioProcessor> processor_;
};
// This fake audio processor is used to verify that the undesired initial values
@@ -145,7 +145,7 @@
public:
explicit FakeAudioTrackWithInitValue(const std::string& id)
: MediaStreamTrack<AudioTrackInterface>(id),
- processor_(rtc::make_ref_counted<FakeAudioProcessorWithInitValue>()) {}
+ processor_(make_ref_counted<FakeAudioProcessorWithInitValue>()) {}
std::string kind() const override { return "audio"; }
AudioSourceInterface* GetSource() const override { return NULL; }
void AddSink(AudioTrackSinkInterface* sink) override {}
@@ -154,12 +154,12 @@
*level = 1;
return true;
}
- rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
+ scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
return processor_;
}
private:
- rtc::scoped_refptr<FakeAudioProcessorWithInitValue> processor_;
+ scoped_refptr<FakeAudioProcessorWithInitValue> processor_;
};
bool GetValue(const StatsReport* report,
@@ -601,8 +601,8 @@
class LegacyStatsCollectorTest : public ::testing::Test {
protected:
- rtc::scoped_refptr<FakePeerConnectionForStats> CreatePeerConnection() {
- return rtc::make_ref_counted<FakePeerConnectionForStats>();
+ scoped_refptr<FakePeerConnectionForStats> CreatePeerConnection() {
+ return make_ref_counted<FakePeerConnectionForStats>();
}
std::unique_ptr<LegacyStatsCollectorForTest> CreateStatsCollector(
@@ -682,7 +682,7 @@
pc->SetTransportStats(kTransportName, channel_stats);
// Fake certificate to report.
- rtc::scoped_refptr<RTCCertificate> local_certificate(
+ scoped_refptr<RTCCertificate> local_certificate(
RTCCertificate::Create(local_identity.Clone()));
pc->SetLocalCertificate(kTransportName, local_certificate);
pc->SetRemoteCertChain(kTransportName,
@@ -736,10 +736,10 @@
AutoThread main_thread_;
};
-static rtc::scoped_refptr<MockRtpSenderInternal> CreateMockSender(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+static scoped_refptr<MockRtpSenderInternal> CreateMockSender(
+ scoped_refptr<MediaStreamTrackInterface> track,
uint32_t ssrc) {
- auto sender = rtc::make_ref_counted<MockRtpSenderInternal>();
+ auto sender = make_ref_counted<MockRtpSenderInternal>();
EXPECT_CALL(*sender, track()).WillRepeatedly(Return(track));
EXPECT_CALL(*sender, ssrc()).WillRepeatedly(Return(ssrc));
EXPECT_CALL(*sender, media_type())
@@ -753,10 +753,10 @@
return sender;
}
-static rtc::scoped_refptr<MockRtpReceiverInternal> CreateMockReceiver(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+static scoped_refptr<MockRtpReceiverInternal> CreateMockReceiver(
+ scoped_refptr<MediaStreamTrackInterface> track,
uint32_t ssrc) {
- auto receiver = rtc::make_ref_counted<MockRtpReceiverInternal>();
+ auto receiver = make_ref_counted<MockRtpReceiverInternal>();
EXPECT_CALL(*receiver, track()).WillRepeatedly(Return(track));
EXPECT_CALL(*receiver, ssrc()).WillRepeatedly(Return(ssrc));
EXPECT_CALL(*receiver, media_type())
@@ -809,10 +809,10 @@
// and register it into the stats object.
// If GetParam() returns true, the track is also inserted into the local
// stream, which is created if necessary.
- rtc::scoped_refptr<RtpSenderInterface> AddOutgoingAudioTrack(
+ scoped_refptr<RtpSenderInterface> AddOutgoingAudioTrack(
FakePeerConnectionForStats* pc,
LegacyStatsCollectorForTest* stats) {
- audio_track_ = rtc::make_ref_counted<FakeAudioTrack>(kLocalTrackId);
+ audio_track_ = make_ref_counted<FakeAudioTrack>(kLocalTrackId);
if (GetParam()) {
if (!stream_)
stream_ = MediaStream::Create("streamid");
@@ -827,7 +827,7 @@
// Adds a incoming audio track with a given SSRC into the stats.
void AddIncomingAudioTrack(FakePeerConnectionForStats* pc,
LegacyStatsCollectorForTest* stats) {
- audio_track_ = rtc::make_ref_counted<FakeAudioTrack>(kRemoteTrackId);
+ audio_track_ = make_ref_counted<FakeAudioTrack>(kRemoteTrackId);
if (GetParam()) {
if (stream_ == nullptr)
stream_ = MediaStream::Create("streamid");
@@ -839,12 +839,12 @@
pc->AddReceiver(CreateMockReceiver(audio_track_, kSsrcOfTrack));
}
- rtc::scoped_refptr<AudioTrackInterface> audio_track() { return audio_track_; }
- rtc::scoped_refptr<VideoTrackInterface> video_track() { return video_track_; }
+ scoped_refptr<AudioTrackInterface> audio_track() { return audio_track_; }
+ scoped_refptr<VideoTrackInterface> video_track() { return video_track_; }
- rtc::scoped_refptr<MediaStream> stream_;
- rtc::scoped_refptr<VideoTrack> video_track_;
- rtc::scoped_refptr<FakeAudioTrack> audio_track_;
+ scoped_refptr<MediaStream> stream_;
+ scoped_refptr<VideoTrack> video_track_;
+ scoped_refptr<FakeAudioTrack> audio_track_;
};
TEST(StatsCollectionTest, DetachAndMerge) {
@@ -1538,8 +1538,8 @@
// Create a local stream with a local audio track and adds it to the stats.
stream_ = MediaStream::Create("streamid");
auto local_track =
- rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kLocalTrackId);
- stream_->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(local_track.get()));
+ make_ref_counted<FakeAudioTrackWithInitValue>(kLocalTrackId);
+ stream_->AddTrack(scoped_refptr<AudioTrackInterface>(local_track.get()));
pc->AddSender(CreateMockSender(local_track, kSsrcOfTrack));
if (GetParam()) {
stats->AddStream(stream_.get());
@@ -1547,10 +1547,10 @@
stats->AddLocalAudioTrack(local_track.get(), kSsrcOfTrack);
// Create a remote stream with a remote audio track and adds it to the stats.
- rtc::scoped_refptr<MediaStream> remote_stream(
+ scoped_refptr<MediaStream> remote_stream(
MediaStream::Create("remotestreamid"));
- rtc::scoped_refptr<AudioTrackInterface> remote_track =
- rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kRemoteTrackId);
+ scoped_refptr<AudioTrackInterface> remote_track =
+ make_ref_counted<FakeAudioTrackWithInitValue>(kRemoteTrackId);
remote_stream->AddTrack(remote_track);
pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
if (GetParam()) {
@@ -1722,10 +1722,10 @@
stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
// Create a remote stream with a remote audio track and adds it to the stats.
- rtc::scoped_refptr<MediaStream> remote_stream(
+ scoped_refptr<MediaStream> remote_stream(
MediaStream::Create("remotestreamid"));
- rtc::scoped_refptr<AudioTrackInterface> remote_track =
- rtc::make_ref_counted<FakeAudioTrack>(kRemoteTrackId);
+ scoped_refptr<AudioTrackInterface> remote_track =
+ make_ref_counted<FakeAudioTrack>(kRemoteTrackId);
pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
remote_stream->AddTrack(remote_track);
stats->AddStream(remote_stream.get());
@@ -1817,10 +1817,9 @@
// Create a new audio track and adds it to the stream and stats.
static const std::string kNewTrackId = "new_track_id";
- auto new_audio_track = rtc::make_ref_counted<FakeAudioTrack>(kNewTrackId);
+ auto new_audio_track = make_ref_counted<FakeAudioTrack>(kNewTrackId);
pc->AddSender(CreateMockSender(new_audio_track, kSsrcOfTrack));
- stream_->AddTrack(
- rtc::scoped_refptr<AudioTrackInterface>(new_audio_track.get()));
+ stream_->AddTrack(scoped_refptr<AudioTrackInterface>(new_audio_track.get()));
stats->AddLocalAudioTrack(new_audio_track.get(), kSsrcOfTrack);
stats->InvalidateCache();
@@ -1850,7 +1849,7 @@
auto stats = CreateStatsCollector(pc.get());
auto local_track =
- rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kLocalTrackId);
+ make_ref_counted<FakeAudioTrackWithInitValue>(kLocalTrackId);
pc->AddSender(CreateMockSender(local_track, kFirstSsrc));
stats->AddLocalAudioTrack(local_track.get(), kFirstSsrc);
pc->AddSender(CreateMockSender(local_track, kSecondSsrc));
diff --git a/pc/local_audio_source.cc b/pc/local_audio_source.cc
index b998886..9e4f35f 100644
--- a/pc/local_audio_source.cc
+++ b/pc/local_audio_source.cc
@@ -19,9 +19,9 @@
namespace webrtc {
-rtc::scoped_refptr<LocalAudioSource> LocalAudioSource::Create(
+scoped_refptr<LocalAudioSource> LocalAudioSource::Create(
const AudioOptions* audio_options) {
- auto source = rtc::make_ref_counted<LocalAudioSource>();
+ auto source = make_ref_counted<LocalAudioSource>();
source->Initialize(audio_options);
return source;
}
diff --git a/pc/local_audio_source.h b/pc/local_audio_source.h
index 22ee69e..84f1207 100644
--- a/pc/local_audio_source.h
+++ b/pc/local_audio_source.h
@@ -24,7 +24,7 @@
class LocalAudioSource : public Notifier<AudioSourceInterface> {
public:
// Creates an instance of LocalAudioSource.
- static rtc::scoped_refptr<LocalAudioSource> Create(
+ static scoped_refptr<LocalAudioSource> Create(
const AudioOptions* audio_options);
SourceState state() const override { return kLive; }
diff --git a/pc/local_audio_source_unittest.cc b/pc/local_audio_source_unittest.cc
index ff78664..7d0c38b 100644
--- a/pc/local_audio_source_unittest.cc
+++ b/pc/local_audio_source_unittest.cc
@@ -21,13 +21,13 @@
TEST(LocalAudioSourceTest, InitWithAudioOptions) {
webrtc::AudioOptions audio_options;
audio_options.highpass_filter = true;
- rtc::scoped_refptr<LocalAudioSource> source =
+ webrtc::scoped_refptr<LocalAudioSource> source =
LocalAudioSource::Create(&audio_options);
EXPECT_EQ(true, source->options().highpass_filter);
}
TEST(LocalAudioSourceTest, InitWithNoOptions) {
- rtc::scoped_refptr<LocalAudioSource> source =
+ webrtc::scoped_refptr<LocalAudioSource> source =
LocalAudioSource::Create(nullptr);
EXPECT_EQ(std::nullopt, source->options().highpass_filter);
}
diff --git a/pc/media_options.cc b/pc/media_options.cc
index 330d1fc..56afb8c 100644
--- a/pc/media_options.cc
+++ b/pc/media_options.cc
@@ -25,14 +25,12 @@
// note: function duplicated in media_session.cc
bool ValidateSimulcastLayers(const std::vector<RidDescription>& rids,
const SimulcastLayerList& simulcast_layers) {
- return absl::c_all_of(simulcast_layers.GetAllLayers(),
- [&rids](const cricket::SimulcastLayer& layer) {
- return absl::c_any_of(
- rids,
- [&layer](const cricket::RidDescription& rid) {
- return rid.rid == layer.rid;
- });
- });
+ return absl::c_all_of(
+ simulcast_layers.GetAllLayers(), [&rids](const SimulcastLayer& layer) {
+ return absl::c_any_of(rids, [&layer](const RidDescription& rid) {
+ return rid.rid == layer.rid;
+ });
+ });
}
} // namespace
diff --git a/pc/media_session.cc b/pc/media_session.cc
index 06f4be5..afff03a 100644
--- a/pc/media_session.cc
+++ b/pc/media_session.cc
@@ -54,10 +54,10 @@
namespace {
-using rtc::UniqueRandomIdGenerator;
using webrtc::RTCError;
using webrtc::RTCErrorType;
using webrtc::RtpTransceiverDirection;
+using webrtc::UniqueRandomIdGenerator;
webrtc::RtpExtension RtpExtensionFromCapability(
const webrtc::RtpHeaderExtensionCapability& capability) {
@@ -66,9 +66,9 @@
capability.preferred_encrypt);
}
-cricket::RtpHeaderExtensions RtpHeaderExtensionsFromCapabilities(
+webrtc::RtpHeaderExtensions RtpHeaderExtensionsFromCapabilities(
const std::vector<webrtc::RtpHeaderExtensionCapability>& capabilities) {
- cricket::RtpHeaderExtensions exts;
+ webrtc::RtpHeaderExtensions exts;
for (const auto& capability : capabilities) {
exts.push_back(RtpExtensionFromCapability(capability));
}
@@ -89,17 +89,17 @@
}
bool IsCapabilityPresent(const webrtc::RtpHeaderExtensionCapability& capability,
- const cricket::RtpHeaderExtensions& extensions) {
+ const webrtc::RtpHeaderExtensions& extensions) {
return std::find_if(extensions.begin(), extensions.end(),
[&capability](const webrtc::RtpExtension& extension) {
return capability.uri == extension.uri;
}) != extensions.end();
}
-cricket::RtpHeaderExtensions UnstoppedOrPresentRtpHeaderExtensions(
+webrtc::RtpHeaderExtensions UnstoppedOrPresentRtpHeaderExtensions(
const std::vector<webrtc::RtpHeaderExtensionCapability>& capabilities,
- const cricket::RtpHeaderExtensions& all_encountered_extensions) {
- cricket::RtpHeaderExtensions extensions;
+ const webrtc::RtpHeaderExtensions& all_encountered_extensions) {
+ webrtc::RtpHeaderExtensions extensions;
for (const auto& capability : capabilities) {
if (capability.direction != RtpTransceiverDirection::kStopped ||
IsCapabilityPresent(capability, all_encountered_extensions)) {
@@ -151,12 +151,11 @@
}
// Finds all StreamParams of all media types and attach them to stream_params.
-cricket::StreamParamsVec GetCurrentStreamParams(
+StreamParamsVec GetCurrentStreamParams(
const std::vector<const ContentInfo*>& active_local_contents) {
- cricket::StreamParamsVec stream_params;
- for (const cricket::ContentInfo* content : active_local_contents) {
- for (const cricket::StreamParams& params :
- content->media_description()->streams()) {
+ StreamParamsVec stream_params;
+ for (const ContentInfo* content : active_local_contents) {
+ for (const StreamParams& params : content->media_description()->streams()) {
stream_params.push_back(params);
}
}
@@ -198,14 +197,12 @@
bool ValidateSimulcastLayers(const std::vector<RidDescription>& rids,
const SimulcastLayerList& simulcast_layers) {
- return absl::c_all_of(simulcast_layers.GetAllLayers(),
- [&rids](const cricket::SimulcastLayer& layer) {
- return absl::c_any_of(
- rids,
- [&layer](const cricket::RidDescription& rid) {
- return rid.rid == layer.rid;
- });
- });
+ return absl::c_all_of(
+ simulcast_layers.GetAllLayers(), [&rids](const SimulcastLayer& layer) {
+ return absl::c_any_of(rids, [&layer](const RidDescription& rid) {
+ return rid.rid == layer.rid;
+ });
+ });
}
StreamParams CreateStreamParamsForNewSenderWithRids(
@@ -266,7 +263,7 @@
bool AddStreamParams(const std::vector<SenderOptions>& sender_options,
const std::string& rtcp_cname,
UniqueRandomIdGenerator* ssrc_generator,
- cricket::StreamParamsVec* current_streams,
+ StreamParamsVec* current_streams,
MediaContentDescription* content_description,
const FieldTrialsView& field_trials) {
// SCTP streams are not negotiated using SDP/ContentDescriptions.
@@ -280,7 +277,7 @@
const bool include_flexfec_stream =
ContainsFlexfecCodec(content_description->codecs());
- for (const cricket::SenderOptions& sender : sender_options) {
+ for (const SenderOptions& sender : sender_options) {
StreamParams* param = GetStreamByIds(*current_streams, sender.track_id);
if (!param) {
// This is a new sender.
@@ -337,7 +334,7 @@
selected_transport_info->description.ice_pwd;
ConnectionRole selected_connection_role =
selected_transport_info->description.connection_role;
- for (cricket::TransportInfo& transport_info : sdesc->transport_infos()) {
+ for (TransportInfo& transport_info : sdesc->transport_infos()) {
if (bundle_group.HasContentName(transport_info.content_name) &&
transport_info.content_name != selected_content_name) {
transport_info.description.ice_ufrag = selected_ufrag;
@@ -374,16 +371,16 @@
RTCError CreateContentOffer(
const MediaDescriptionOptions& media_description_options,
const MediaSessionOptions& session_options,
- const cricket::RtpHeaderExtensions& rtp_extensions,
+ const RtpHeaderExtensions& rtp_extensions,
UniqueRandomIdGenerator* ssrc_generator,
- cricket::StreamParamsVec* current_streams,
+ StreamParamsVec* current_streams,
MediaContentDescription* offer) {
offer->set_rtcp_mux(session_options.rtcp_mux_enabled);
offer->set_rtcp_reduced_size(true);
// Build the vector of header extensions with directions for this
// media_description's options.
- cricket::RtpHeaderExtensions extensions;
+ RtpHeaderExtensions extensions;
for (const auto& extension_with_id : rtp_extensions) {
for (const auto& extension : media_description_options.header_extensions) {
if (extension_with_id.uri == extension.uri &&
@@ -408,9 +405,9 @@
const MediaDescriptionOptions& media_description_options,
const MediaSessionOptions& session_options,
const std::vector<Codec>& codecs,
- const cricket::RtpHeaderExtensions& rtp_extensions,
+ const RtpHeaderExtensions& rtp_extensions,
UniqueRandomIdGenerator* ssrc_generator,
- cricket::StreamParamsVec* current_streams,
+ StreamParamsVec* current_streams,
MediaContentDescription* offer,
const FieldTrialsView& field_trials) {
offer->AddCodecs(codecs);
@@ -433,10 +430,10 @@
// for that extension. `offered_extensions` is for either audio or video while
// `all_encountered_extensions` is used for both audio and video. There could be
// overlap between audio extensions and video extensions.
-void MergeRtpHdrExts(const cricket::RtpHeaderExtensions& reference_extensions,
+void MergeRtpHdrExts(const RtpHeaderExtensions& reference_extensions,
bool enable_encrypted_rtp_header_extensions,
- cricket::RtpHeaderExtensions* offered_extensions,
- cricket::RtpHeaderExtensions* all_encountered_extensions,
+ RtpHeaderExtensions* offered_extensions,
+ RtpHeaderExtensions* all_encountered_extensions,
UsedRtpHeaderExtensionIds* used_ids) {
for (auto reference_extension : reference_extensions) {
if (!RtpExtension::FindHeaderExtensionByUriAndEncryption(
@@ -489,11 +486,10 @@
return RtpExtension::FindHeaderExtensionByUri(extensions, uri, filter);
}
-void NegotiateRtpHeaderExtensions(
- const cricket::RtpHeaderExtensions& local_extensions,
- const cricket::RtpHeaderExtensions& offered_extensions,
- RtpExtension::Filter filter,
- cricket::RtpHeaderExtensions* negotiated_extensions) {
+void NegotiateRtpHeaderExtensions(const RtpHeaderExtensions& local_extensions,
+ const RtpHeaderExtensions& offered_extensions,
+ RtpExtension::Filter filter,
+ RtpHeaderExtensions* negotiated_extensions) {
bool frame_descriptor_in_local = false;
bool dependency_descriptor_in_local = false;
bool abs_capture_time_in_local = false;
@@ -547,7 +543,7 @@
const MediaDescriptionOptions& media_description_options,
const MediaSessionOptions& session_options,
UniqueRandomIdGenerator* ssrc_generator,
- cricket::StreamParamsVec* current_streams,
+ StreamParamsVec* current_streams,
MediaContentDescription* answer,
const FieldTrialsView& field_trials) {
RTC_DCHECK(offer->type() == webrtc::MediaType::AUDIO ||
@@ -573,10 +569,10 @@
const MediaContentDescription* offer,
const MediaDescriptionOptions& media_description_options,
const MediaSessionOptions& session_options,
- const cricket::RtpHeaderExtensions& local_rtp_extensions,
+ const RtpHeaderExtensions& local_rtp_extensions,
UniqueRandomIdGenerator* ssrc_generator,
bool enable_encrypted_rtp_header_extensions,
- cricket::StreamParamsVec* current_streams,
+ StreamParamsVec* current_streams,
bool bundle_enabled,
MediaContentDescription* answer) {
answer->set_extmap_allow_mixed_enum(offer->extmap_allow_mixed_enum());
@@ -586,7 +582,7 @@
: RtpExtension::Filter::kDiscardEncryptedExtension;
// Filter local extensions by capabilities and direction.
- cricket::RtpHeaderExtensions local_rtp_extensions_to_reply_with;
+ RtpHeaderExtensions local_rtp_extensions_to_reply_with;
for (const auto& extension_with_id : local_rtp_extensions) {
for (const auto& extension : media_description_options.header_extensions) {
if (extension_with_id.uri == extension.uri &&
@@ -601,7 +597,7 @@
}
}
}
- cricket::RtpHeaderExtensions negotiated_rtp_extensions;
+ RtpHeaderExtensions negotiated_rtp_extensions;
NegotiateRtpHeaderExtensions(local_rtp_extensions_to_reply_with,
offer->rtp_header_extensions(),
extensions_filter, &negotiated_rtp_extensions);
@@ -689,9 +685,9 @@
RTC_CHECK(codec_lookup_helper_);
}
-cricket::RtpHeaderExtensions
+RtpHeaderExtensions
MediaSessionDescriptionFactory::filtered_rtp_header_extensions(
- cricket::RtpHeaderExtensions extensions) const {
+ RtpHeaderExtensions extensions) const {
if (!is_unified_plan_) {
// Remove extensions only supported with unified-plan.
extensions.erase(
@@ -725,7 +721,7 @@
GetActiveContents(*current_description, session_options);
}
- cricket::StreamParamsVec current_streams =
+ StreamParamsVec current_streams =
GetCurrentStreamParams(current_active_contents);
AudioVideoRtpHeaderExtensions extensions_with_ids =
@@ -738,7 +734,7 @@
// Iterate through the media description options, matching with existing media
// descriptions in `current_description`.
size_t msection_index = 0;
- for (const cricket::MediaDescriptionOptions& media_description_options :
+ for (const MediaDescriptionOptions& media_description_options :
session_options.media_description_options) {
const ContentInfo* current_content = nullptr;
if (current_description &&
@@ -782,7 +778,7 @@
// parameters that need to be tweaked for BUNDLE.
if (session_options.bundle_enabled) {
ContentGroup offer_bundle(GROUP_TYPE_BUNDLE);
- for (const cricket::ContentInfo& content : offer->contents()) {
+ for (const ContentInfo& content : offer->contents()) {
if (content.rejected) {
continue;
}
@@ -845,7 +841,7 @@
GetActiveContents(*current_description, session_options);
}
- cricket::StreamParamsVec current_streams =
+ StreamParamsVec current_streams =
GetCurrentStreamParams(current_active_contents);
// Decide what congestion control feedback format we're using.
@@ -887,7 +883,7 @@
// Iterate through the media description options, matching with existing
// media descriptions in `current_description`.
size_t msection_index = 0;
- for (const cricket::MediaDescriptionOptions& media_description_options :
+ for (const MediaDescriptionOptions& media_description_options :
session_options.media_description_options) {
const ContentInfo* offer_content = &offer->contents()[msection_index];
// Media types and MIDs must match between the remote offer and the
@@ -921,9 +917,8 @@
}
}
}
- cricket::RtpHeaderExtensions header_extensions =
- RtpHeaderExtensionsFromCapabilities(
- UnstoppedRtpHeaderExtensionCapabilities(header_extensions_in));
+ RtpHeaderExtensions header_extensions = RtpHeaderExtensionsFromCapabilities(
+ UnstoppedRtpHeaderExtensionCapabilities(header_extensions_in));
RTCError error;
switch (media_description_options.type) {
case webrtc::MediaType::AUDIO:
@@ -973,7 +968,7 @@
// with semantics that are understood MUST return an answer that
// contains an "a=group" line with the same semantics.
if (!offer_bundles.empty()) {
- for (const cricket::ContentGroup& answer_bundle : answer_bundles) {
+ for (const ContentGroup& answer_bundle : answer_bundles) {
answer->AddGroup(answer_bundle);
if (answer_bundle.FirstContentName()) {
@@ -1049,14 +1044,14 @@
extmap_allow_mixed ? UsedRtpHeaderExtensionIds::IdDomain::kTwoByteAllowed
: UsedRtpHeaderExtensionIds::IdDomain::kOneByteOnly);
- cricket::RtpHeaderExtensions all_encountered_extensions;
+ RtpHeaderExtensions all_encountered_extensions;
AudioVideoRtpHeaderExtensions offered_extensions;
// First - get all extensions from the current description if the media type
// is used.
// Add them to `used_ids` so the local ids are not reused if a new media
// type is added.
- for (const cricket::ContentInfo* content : current_active_contents) {
+ for (const ContentInfo* content : current_active_contents) {
if (IsMediaContentOfType(content, webrtc::MediaType::AUDIO)) {
MergeRtpHdrExts(content->media_description()->rtp_header_extensions(),
enable_encrypted_rtp_header_extensions_,
@@ -1074,7 +1069,7 @@
// are not in the current description.
for (const auto& entry : media_description_options) {
- cricket::RtpHeaderExtensions filtered_extensions =
+ RtpHeaderExtensions filtered_extensions =
filtered_rtp_header_extensions(UnstoppedOrPresentRtpHeaderExtensions(
entry.header_extensions, all_encountered_extensions));
if (entry.type == webrtc::MediaType::AUDIO)
@@ -1155,8 +1150,8 @@
const MediaSessionOptions& session_options,
const ContentInfo* current_content,
const SessionDescription* current_description,
- const cricket::RtpHeaderExtensions& header_extensions,
- cricket::StreamParamsVec* current_streams,
+ const RtpHeaderExtensions& header_extensions,
+ StreamParamsVec* current_streams,
SessionDescription* session_description,
IceCredentialsIterator* ice_credentials) const {
RTC_DCHECK(media_description_options.type == webrtc::MediaType::AUDIO ||
@@ -1212,7 +1207,7 @@
const MediaSessionOptions& session_options,
const ContentInfo* current_content,
const SessionDescription* current_description,
- cricket::StreamParamsVec* current_streams,
+ StreamParamsVec* current_streams,
SessionDescription* desc,
IceCredentialsIterator* ice_credentials) const {
auto data = std::make_unique<SctpDataContentDescription>();
@@ -1229,10 +1224,9 @@
data->set_use_sctpmap(session_options.use_obsolete_sctp_sdp);
data->set_max_message_size(webrtc::kSctpSendBufferSize);
- auto error =
- CreateContentOffer(media_description_options, session_options,
- cricket::RtpHeaderExtensions(), ssrc_generator(),
- current_streams, data.get());
+ auto error = CreateContentOffer(media_description_options, session_options,
+ RtpHeaderExtensions(), ssrc_generator(),
+ current_streams, data.get());
if (!error.ok()) {
return error;
}
@@ -1287,8 +1281,8 @@
const ContentInfo* current_content,
const SessionDescription* current_description,
const TransportInfo* bundle_transport,
- const cricket::RtpHeaderExtensions& header_extensions,
- cricket::StreamParamsVec* current_streams,
+ const RtpHeaderExtensions& header_extensions,
+ StreamParamsVec* current_streams,
SessionDescription* answer,
IceCredentialsIterator* ice_credentials) const {
RTC_DCHECK(media_description_options.type == webrtc::MediaType::AUDIO ||
@@ -1405,7 +1399,7 @@
const ContentInfo* current_content,
const SessionDescription* current_description,
const TransportInfo* bundle_transport,
- cricket::StreamParamsVec* current_streams,
+ StreamParamsVec* current_streams,
SessionDescription* answer,
IceCredentialsIterator* ice_credentials) const {
std::unique_ptr<TransportDescription> data_transport = CreateTransportAnswer(
@@ -1443,7 +1437,7 @@
}
if (!CreateMediaContentAnswer(
offer_data_description, media_description_options, session_options,
- cricket::RtpHeaderExtensions(), ssrc_generator(),
+ RtpHeaderExtensions(), ssrc_generator(),
enable_encrypted_rtp_header_extensions_, current_streams,
bundle_enabled, data_answer.get())) {
LOG_AND_RETURN_ERROR(RTCErrorType::INTERNAL_ERROR,
@@ -1536,9 +1530,9 @@
return IsMediaContentOfType(content, webrtc::MediaType::UNSUPPORTED);
}
-const ContentInfo* GetFirstMediaContent(const cricket::ContentInfos& contents,
+const ContentInfo* GetFirstMediaContent(const ContentInfos& contents,
webrtc::MediaType media_type) {
- for (const cricket::ContentInfo& content : contents) {
+ for (const ContentInfo& content : contents) {
if (IsMediaContentOfType(&content, media_type)) {
return &content;
}
@@ -1546,15 +1540,15 @@
return nullptr;
}
-const ContentInfo* GetFirstAudioContent(const cricket::ContentInfos& contents) {
+const ContentInfo* GetFirstAudioContent(const ContentInfos& contents) {
return GetFirstMediaContent(contents, webrtc::MediaType::AUDIO);
}
-const ContentInfo* GetFirstVideoContent(const cricket::ContentInfos& contents) {
+const ContentInfo* GetFirstVideoContent(const ContentInfos& contents) {
return GetFirstMediaContent(contents, webrtc::MediaType::VIDEO);
}
-const ContentInfo* GetFirstDataContent(const cricket::ContentInfos& contents) {
+const ContentInfo* GetFirstDataContent(const ContentInfos& contents) {
return GetFirstMediaContent(contents, webrtc::MediaType::DATA);
}
@@ -1608,9 +1602,9 @@
// Non-const versions of the above functions.
//
-ContentInfo* GetFirstMediaContent(cricket::ContentInfos* contents,
+ContentInfo* GetFirstMediaContent(ContentInfos* contents,
webrtc::MediaType media_type) {
- for (cricket::ContentInfo& content : *contents) {
+ for (ContentInfo& content : *contents) {
if (IsMediaContentOfType(&content, media_type)) {
return &content;
}
@@ -1618,15 +1612,15 @@
return nullptr;
}
-ContentInfo* GetFirstAudioContent(cricket::ContentInfos* contents) {
+ContentInfo* GetFirstAudioContent(ContentInfos* contents) {
return GetFirstMediaContent(contents, webrtc::MediaType::AUDIO);
}
-ContentInfo* GetFirstVideoContent(cricket::ContentInfos* contents) {
+ContentInfo* GetFirstVideoContent(ContentInfos* contents) {
return GetFirstMediaContent(contents, webrtc::MediaType::VIDEO);
}
-ContentInfo* GetFirstDataContent(cricket::ContentInfos* contents) {
+ContentInfo* GetFirstDataContent(ContentInfos* contents) {
return GetFirstMediaContent(contents, webrtc::MediaType::DATA);
}
diff --git a/pc/media_session.h b/pc/media_session.h
index 40f966e..4257bfb 100644
--- a/pc/media_session.h
+++ b/pc/media_session.h
@@ -57,8 +57,8 @@
const TransportDescriptionFactory* factory,
CodecLookupHelper* codec_lookup_helper);
- cricket::RtpHeaderExtensions filtered_rtp_header_extensions(
- cricket::RtpHeaderExtensions extensions) const;
+ RtpHeaderExtensions filtered_rtp_header_extensions(
+ RtpHeaderExtensions extensions) const;
void set_enable_encrypted_rtp_header_extensions(bool enable) {
enable_encrypted_rtp_header_extensions_ = enable;
@@ -78,8 +78,8 @@
private:
struct AudioVideoRtpHeaderExtensions {
- cricket::RtpHeaderExtensions audio;
- cricket::RtpHeaderExtensions video;
+ RtpHeaderExtensions audio;
+ RtpHeaderExtensions video;
};
AudioVideoRtpHeaderExtensions GetOfferedRtpHeaderExtensionsWithIds(
@@ -111,8 +111,8 @@
const MediaSessionOptions& session_options,
const ContentInfo* current_content,
const SessionDescription* current_description,
- const cricket::RtpHeaderExtensions& header_extensions,
- cricket::StreamParamsVec* current_streams,
+ const RtpHeaderExtensions& header_extensions,
+ StreamParamsVec* current_streams,
SessionDescription* desc,
IceCredentialsIterator* ice_credentials) const;
@@ -121,7 +121,7 @@
const MediaSessionOptions& session_options,
const ContentInfo* current_content,
const SessionDescription* current_description,
- cricket::StreamParamsVec* current_streams,
+ StreamParamsVec* current_streams,
SessionDescription* desc,
IceCredentialsIterator* ice_credentials) const;
@@ -141,8 +141,8 @@
const ContentInfo* current_content,
const SessionDescription* current_description,
const TransportInfo* bundle_transport,
- const cricket::RtpHeaderExtensions& header_extensions,
- cricket::StreamParamsVec* current_streams,
+ const RtpHeaderExtensions& header_extensions,
+ StreamParamsVec* current_streams,
SessionDescription* answer,
IceCredentialsIterator* ice_credentials) const;
@@ -154,7 +154,7 @@
const ContentInfo* current_content,
const SessionDescription* current_description,
const TransportInfo* bundle_transport,
- cricket::StreamParamsVec* current_streams,
+ StreamParamsVec* current_streams,
SessionDescription* answer,
IceCredentialsIterator* ice_credentials) const;
@@ -188,11 +188,11 @@
bool IsVideoContent(const ContentInfo* content);
bool IsDataContent(const ContentInfo* content);
bool IsUnsupportedContent(const ContentInfo* content);
-const ContentInfo* GetFirstMediaContent(const cricket::ContentInfos& contents,
+const ContentInfo* GetFirstMediaContent(const ContentInfos& contents,
webrtc::MediaType media_type);
-const ContentInfo* GetFirstAudioContent(const cricket::ContentInfos& contents);
-const ContentInfo* GetFirstVideoContent(const cricket::ContentInfos& contents);
-const ContentInfo* GetFirstDataContent(const cricket::ContentInfos& contents);
+const ContentInfo* GetFirstAudioContent(const ContentInfos& contents);
+const ContentInfo* GetFirstVideoContent(const ContentInfos& contents);
+const ContentInfo* GetFirstDataContent(const ContentInfos& contents);
const ContentInfo* GetFirstMediaContent(const SessionDescription* sdesc,
webrtc::MediaType media_type);
const ContentInfo* GetFirstAudioContent(const SessionDescription* sdesc);
@@ -206,11 +206,11 @@
const SessionDescription* sdesc);
// Non-const versions of the above functions.
// Useful when modifying an existing description.
-ContentInfo* GetFirstMediaContent(cricket::ContentInfos* contents,
+ContentInfo* GetFirstMediaContent(ContentInfos* contents,
webrtc::MediaType media_type);
-ContentInfo* GetFirstAudioContent(cricket::ContentInfos* contents);
-ContentInfo* GetFirstVideoContent(cricket::ContentInfos* contents);
-ContentInfo* GetFirstDataContent(cricket::ContentInfos* contents);
+ContentInfo* GetFirstAudioContent(ContentInfos* contents);
+ContentInfo* GetFirstVideoContent(ContentInfos* contents);
+ContentInfo* GetFirstDataContent(ContentInfos* contents);
ContentInfo* GetFirstMediaContent(SessionDescription* sdesc,
webrtc::MediaType media_type);
ContentInfo* GetFirstAudioContent(SessionDescription* sdesc);
diff --git a/pc/media_session_unittest.cc b/pc/media_session_unittest.cc
index eef2044..ea8c045 100644
--- a/pc/media_session_unittest.cc
+++ b/pc/media_session_unittest.cc
@@ -66,7 +66,6 @@
namespace webrtc {
namespace {
-using ::rtc::UniqueRandomIdGenerator;
using ::testing::Bool;
using ::testing::Combine;
using ::testing::Contains;
@@ -82,6 +81,7 @@
using ::testing::UnorderedElementsAreArray;
using ::testing::Values;
using ::testing::ValuesIn;
+using ::webrtc::UniqueRandomIdGenerator;
using ::webrtc::test::ScopedKeyValueConfig;
using Candidates = std::vector<Candidate>;
@@ -189,8 +189,8 @@
const Codec kVideoCodecsH265Level6[] = {
CreateVideoCodec(96, kH265MainProfileLevel6Sdp)};
// Match two codec lists for content, but ignore the ID.
-bool CodecListsMatch(rtc::ArrayView<const Codec> list1,
- rtc::ArrayView<const Codec> list2) {
+bool CodecListsMatch(ArrayView<const Codec> list1,
+ ArrayView<const Codec> list2) {
if (list1.size() != list2.size()) {
return false;
}
@@ -428,19 +428,17 @@
std::vector<MediaDescriptionOptions>::iterator FindFirstMediaDescriptionByMid(
const std::string& mid,
MediaSessionOptions* opts) {
- return absl::c_find_if(opts->media_description_options,
- [&mid](const cricket::MediaDescriptionOptions& t) {
- return t.mid == mid;
- });
+ return absl::c_find_if(
+ opts->media_description_options,
+ [&mid](const MediaDescriptionOptions& t) { return t.mid == mid; });
}
std::vector<MediaDescriptionOptions>::const_iterator
FindFirstMediaDescriptionByMid(const std::string& mid,
const MediaSessionOptions& opts) {
- return absl::c_find_if(opts.media_description_options,
- [&mid](const cricket::MediaDescriptionOptions& t) {
- return t.mid == mid;
- });
+ return absl::c_find_if(
+ opts.media_description_options,
+ [&mid](const MediaDescriptionOptions& t) { return t.mid == mid; });
}
// Add a media section to the `session_options`.
@@ -507,11 +505,10 @@
MediaSessionOptions* session_options) {
std::vector<SenderOptions>& sender_options_list =
FindFirstMediaDescriptionByMid(mid, session_options)->sender_options;
- auto sender_it =
- absl::c_find_if(sender_options_list,
- [track_id](const cricket::SenderOptions& sender_options) {
- return sender_options.track_id == track_id;
- });
+ auto sender_it = absl::c_find_if(
+ sender_options_list, [track_id](const SenderOptions& sender_options) {
+ return sender_options.track_id == track_id;
+ });
RTC_DCHECK(sender_it != sender_options_list.end());
sender_options_list.erase(sender_it);
}
@@ -554,7 +551,7 @@
// Create a video StreamParamsVec object with:
// - one video stream with 3 simulcast streams and FEC,
- cricket::StreamParamsVec CreateComplexVideoStreamParamsVec() {
+ StreamParamsVec CreateComplexVideoStreamParamsVec() {
SsrcGroup sim_group("SIM", MAKE_VECTOR(kSimSsrc));
SsrcGroup fec_group1("FEC", MAKE_VECTOR(kFec1Ssrc));
SsrcGroup fec_group2("FEC", MAKE_VECTOR(kFec2Ssrc));
@@ -573,7 +570,7 @@
simulcast_params.cname = "Video_SIM_FEC";
simulcast_params.set_stream_ids({kMediaStream1});
- cricket::StreamParamsVec video_streams;
+ StreamParamsVec video_streams;
video_streams.push_back(simulcast_params);
return video_streams;
@@ -724,9 +721,9 @@
}
void TestTransportSequenceNumberNegotiation(
- const cricket::RtpHeaderExtensions& local,
- const cricket::RtpHeaderExtensions& offered,
- const cricket::RtpHeaderExtensions& expectedAnswer) {
+ const RtpHeaderExtensions& local,
+ const RtpHeaderExtensions& offered,
+ const RtpHeaderExtensions& expectedAnswer) {
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
SetAudioVideoRtpHeaderExtensions(offered, offered, &opts);
@@ -748,8 +745,7 @@
}
std::vector<RtpHeaderExtensionCapability>
- HeaderExtensionCapabilitiesFromRtpExtensions(
- cricket::RtpHeaderExtensions extensions) {
+ HeaderExtensionCapabilitiesFromRtpExtensions(RtpHeaderExtensions extensions) {
std::vector<RtpHeaderExtensionCapability> capabilities;
for (const auto& extension : extensions) {
RtpHeaderExtensionCapability capability(
@@ -760,8 +756,8 @@
return capabilities;
}
- void SetAudioVideoRtpHeaderExtensions(cricket::RtpHeaderExtensions audio_exts,
- cricket::RtpHeaderExtensions video_exts,
+ void SetAudioVideoRtpHeaderExtensions(RtpHeaderExtensions audio_exts,
+ RtpHeaderExtensions video_exts,
MediaSessionOptions* opts) {
std::vector<RtpHeaderExtensionCapability> audio_caps =
HeaderExtensionCapabilitiesFromRtpExtensions(audio_exts);
@@ -1931,9 +1927,9 @@
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
- const cricket::RtpHeaderExtensions offered_extensions = {
+ const RtpHeaderExtensions offered_extensions = {
RtpExtension(RtpExtension::kAbsoluteCaptureTimeUri, 7)};
- const cricket::RtpHeaderExtensions local_extensions = {
+ const RtpHeaderExtensions local_extensions = {
RtpExtension(RtpExtension::kTransportSequenceNumberUri, 5)};
SetAudioVideoRtpHeaderExtensions(offered_extensions, offered_extensions,
&opts);
@@ -1955,9 +1951,9 @@
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
- const cricket::RtpHeaderExtensions offered_extensions = {
+ const RtpHeaderExtensions offered_extensions = {
RtpExtension(RtpExtension::kAbsoluteCaptureTimeUri, 7)};
- const cricket::RtpHeaderExtensions local_extensions = {
+ const RtpHeaderExtensions local_extensions = {
RtpExtension(RtpExtension::kAbsoluteCaptureTimeUri, 5)};
SetAudioVideoRtpHeaderExtensions(offered_extensions, offered_extensions,
&opts);
@@ -1979,9 +1975,9 @@
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
- const cricket::RtpHeaderExtensions offered_extensions = {
+ const RtpHeaderExtensions offered_extensions = {
RtpExtension(RtpExtension::kTransportSequenceNumberUri, 7)};
- const cricket::RtpHeaderExtensions local_extensions = {
+ const RtpHeaderExtensions local_extensions = {
RtpExtension(RtpExtension::kAbsoluteCaptureTimeUri, 5)};
SetAudioVideoRtpHeaderExtensions(offered_extensions, offered_extensions,
&opts);
@@ -2687,7 +2683,7 @@
codec_lookup_helper_1_.CodecVendor("")->audio_sendrecv_codecs().codecs(),
acd->codecs());
- const cricket::StreamParamsVec& audio_streams = acd->streams();
+ const StreamParamsVec& audio_streams = acd->streams();
ASSERT_EQ(2U, audio_streams.size());
EXPECT_EQ(audio_streams[0].cname, audio_streams[1].cname);
EXPECT_EQ(kAudioTrack1, audio_streams[0].id);
@@ -2706,7 +2702,7 @@
codec_lookup_helper_1_.CodecVendor("")->video_sendrecv_codecs().codecs(),
vcd->codecs());
- const cricket::StreamParamsVec& video_streams = vcd->streams();
+ const StreamParamsVec& video_streams = vcd->streams();
ASSERT_EQ(1U, video_streams.size());
EXPECT_EQ(video_streams[0].cname, audio_streams[0].cname);
EXPECT_EQ(kVideoTrack1, video_streams[0].id);
@@ -2739,8 +2735,7 @@
EXPECT_EQ(vcd->type(), updated_vcd->type());
EXPECT_EQ(vcd->codecs(), updated_vcd->codecs());
- const cricket::StreamParamsVec& updated_audio_streams =
- updated_acd->streams();
+ const StreamParamsVec& updated_audio_streams = updated_acd->streams();
ASSERT_EQ(2U, updated_audio_streams.size());
EXPECT_EQ(audio_streams[0], updated_audio_streams[0]);
EXPECT_EQ(kAudioTrack3, updated_audio_streams[1].id); // New audio track.
@@ -2748,8 +2743,7 @@
EXPECT_NE(0U, updated_audio_streams[1].ssrcs[0]);
EXPECT_EQ(updated_audio_streams[0].cname, updated_audio_streams[1].cname);
- const cricket::StreamParamsVec& updated_video_streams =
- updated_vcd->streams();
+ const StreamParamsVec& updated_video_streams = updated_vcd->streams();
ASSERT_EQ(2U, updated_video_streams.size());
EXPECT_EQ(video_streams[0], updated_video_streams[0]);
EXPECT_EQ(kVideoTrack2, updated_video_streams[1].id);
@@ -2778,7 +2772,7 @@
ASSERT_TRUE(vc);
const MediaContentDescription* vcd = vc->media_description();
- const cricket::StreamParamsVec& video_streams = vcd->streams();
+ const StreamParamsVec& video_streams = vcd->streams();
ASSERT_EQ(1U, video_streams.size());
EXPECT_EQ(kVideoTrack1, video_streams[0].id);
const SsrcGroup* sim_ssrc_group =
@@ -2803,7 +2797,7 @@
ASSERT_NE(content, nullptr);
const MediaContentDescription* cd = content->media_description();
ASSERT_NE(cd, nullptr);
- const cricket::StreamParamsVec& streams = cd->streams();
+ const StreamParamsVec& streams = cd->streams();
ASSERT_THAT(streams, SizeIs(1));
const StreamParams& stream = streams[0];
ASSERT_THAT(stream.ssrcs, IsEmpty());
@@ -2863,7 +2857,7 @@
ASSERT_NE(content, nullptr);
const MediaContentDescription* cd = content->media_description();
ASSERT_NE(cd, nullptr);
- const cricket::StreamParamsVec& streams = cd->streams();
+ const StreamParamsVec& streams = cd->streams();
ASSERT_THAT(streams, SizeIs(1));
const StreamParams& stream = streams[0];
ASSERT_THAT(stream.ssrcs, IsEmpty());
@@ -2940,7 +2934,7 @@
ASSERT_NE(content, nullptr);
const MediaContentDescription* cd = content->media_description();
ASSERT_NE(cd, nullptr);
- const cricket::StreamParamsVec& streams = cd->streams();
+ const StreamParamsVec& streams = cd->streams();
ASSERT_THAT(streams, SizeIs(1));
const StreamParams& stream = streams[0];
ASSERT_THAT(stream.ssrcs, IsEmpty());
@@ -2996,7 +2990,7 @@
EXPECT_EQ(webrtc::MediaType::AUDIO, acd->type());
EXPECT_THAT(acd->codecs(), ElementsAreArray(kAudioCodecsAnswer));
- const cricket::StreamParamsVec& audio_streams = acd->streams();
+ const StreamParamsVec& audio_streams = acd->streams();
ASSERT_EQ(2U, audio_streams.size());
EXPECT_TRUE(audio_streams[0].cname == audio_streams[1].cname);
EXPECT_EQ(kAudioTrack1, audio_streams[0].id);
@@ -3013,7 +3007,7 @@
EXPECT_EQ(webrtc::MediaType::VIDEO, vcd->type());
EXPECT_THAT(vcd->codecs(), ElementsAreArray(kVideoCodecsAnswer));
- const cricket::StreamParamsVec& video_streams = vcd->streams();
+ const StreamParamsVec& video_streams = vcd->streams();
ASSERT_EQ(1U, video_streams.size());
EXPECT_EQ(video_streams[0].cname, audio_streams[0].cname);
EXPECT_EQ(kVideoTrack1, video_streams[0].id);
@@ -3044,13 +3038,11 @@
EXPECT_EQ(vcd->type(), updated_vcd->type());
EXPECT_EQ(vcd->codecs(), updated_vcd->codecs());
- const cricket::StreamParamsVec& updated_audio_streams =
- updated_acd->streams();
+ const StreamParamsVec& updated_audio_streams = updated_acd->streams();
ASSERT_EQ(1U, updated_audio_streams.size());
EXPECT_TRUE(audio_streams[0] == updated_audio_streams[0]);
- const cricket::StreamParamsVec& updated_video_streams =
- updated_vcd->streams();
+ const StreamParamsVec& updated_video_streams = updated_vcd->streams();
ASSERT_EQ(2U, updated_video_streams.size());
EXPECT_EQ(video_streams[0], updated_video_streams[0]);
EXPECT_EQ(kVideoTrack2, updated_video_streams[1].id);
@@ -3636,7 +3628,7 @@
MediaContentDescription* media_desc =
offer->GetContentDescriptionByName(CN_VIDEO);
ASSERT_TRUE(media_desc);
- const cricket::StreamParamsVec& streams = media_desc->streams();
+ const StreamParamsVec& streams = media_desc->streams();
// Single stream.
ASSERT_EQ(1u, streams.size());
// Stream should have 6 ssrcs: 3 for video, 3 for RTX.
@@ -3681,7 +3673,7 @@
MediaContentDescription* media_desc =
offer->GetContentDescriptionByName(CN_VIDEO);
ASSERT_TRUE(media_desc);
- const cricket::StreamParamsVec& streams = media_desc->streams();
+ const StreamParamsVec& streams = media_desc->streams();
// Single stream.
ASSERT_EQ(1u, streams.size());
// Stream should have 2 ssrcs: 1 for video, 1 for FlexFEC.
@@ -3725,7 +3717,7 @@
MediaContentDescription* media_desc =
offer->GetContentDescriptionByName(CN_VIDEO);
ASSERT_TRUE(media_desc);
- const cricket::StreamParamsVec& streams = media_desc->streams();
+ const StreamParamsVec& streams = media_desc->streams();
// Single stream.
ASSERT_EQ(1u, streams.size());
// Stream should have 3 ssrcs: 3 for video, 0 for FlexFEC.
diff --git a/pc/media_stream.cc b/pc/media_stream.cc
index b8366af..7c62bff 100644
--- a/pc/media_stream.cc
+++ b/pc/media_stream.cc
@@ -33,29 +33,29 @@
return it;
}
-rtc::scoped_refptr<MediaStream> MediaStream::Create(const std::string& id) {
- return rtc::make_ref_counted<MediaStream>(id);
+scoped_refptr<MediaStream> MediaStream::Create(const std::string& id) {
+ return make_ref_counted<MediaStream>(id);
}
MediaStream::MediaStream(const std::string& id) : id_(id) {}
-bool MediaStream::AddTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
+bool MediaStream::AddTrack(scoped_refptr<AudioTrackInterface> track) {
return AddTrack<AudioTrackVector, AudioTrackInterface>(&audio_tracks_, track);
}
-bool MediaStream::AddTrack(rtc::scoped_refptr<VideoTrackInterface> track) {
+bool MediaStream::AddTrack(scoped_refptr<VideoTrackInterface> track) {
return AddTrack<VideoTrackVector, VideoTrackInterface>(&video_tracks_, track);
}
-bool MediaStream::RemoveTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
+bool MediaStream::RemoveTrack(scoped_refptr<AudioTrackInterface> track) {
return RemoveTrack<AudioTrackVector>(&audio_tracks_, track);
}
-bool MediaStream::RemoveTrack(rtc::scoped_refptr<VideoTrackInterface> track) {
+bool MediaStream::RemoveTrack(scoped_refptr<VideoTrackInterface> track) {
return RemoveTrack<VideoTrackVector>(&video_tracks_, track);
}
-rtc::scoped_refptr<AudioTrackInterface> MediaStream::FindAudioTrack(
+scoped_refptr<AudioTrackInterface> MediaStream::FindAudioTrack(
const std::string& track_id) {
AudioTrackVector::iterator it = FindTrack(&audio_tracks_, track_id);
if (it == audio_tracks_.end())
@@ -63,7 +63,7 @@
return *it;
}
-rtc::scoped_refptr<VideoTrackInterface> MediaStream::FindVideoTrack(
+scoped_refptr<VideoTrackInterface> MediaStream::FindVideoTrack(
const std::string& track_id) {
VideoTrackVector::iterator it = FindTrack(&video_tracks_, track_id);
if (it == video_tracks_.end())
@@ -72,8 +72,7 @@
}
template <typename TrackVector, typename Track>
-bool MediaStream::AddTrack(TrackVector* tracks,
- rtc::scoped_refptr<Track> track) {
+bool MediaStream::AddTrack(TrackVector* tracks, scoped_refptr<Track> track) {
typename TrackVector::iterator it = FindTrack(tracks, track->id());
if (it != tracks->end())
return false;
@@ -83,9 +82,8 @@
}
template <typename TrackVector>
-bool MediaStream::RemoveTrack(
- TrackVector* tracks,
- rtc::scoped_refptr<MediaStreamTrackInterface> track) {
+bool MediaStream::RemoveTrack(TrackVector* tracks,
+ scoped_refptr<MediaStreamTrackInterface> track) {
RTC_DCHECK(tracks != NULL);
if (!track)
return false;
diff --git a/pc/media_stream.h b/pc/media_stream.h
index c033cf6..108a4b6 100644
--- a/pc/media_stream.h
+++ b/pc/media_stream.h
@@ -23,17 +23,17 @@
class MediaStream : public Notifier<MediaStreamInterface> {
public:
- static rtc::scoped_refptr<MediaStream> Create(const std::string& id);
+ static scoped_refptr<MediaStream> Create(const std::string& id);
std::string id() const override { return id_; }
- bool AddTrack(rtc::scoped_refptr<AudioTrackInterface> track) override;
- bool AddTrack(rtc::scoped_refptr<VideoTrackInterface> track) override;
- bool RemoveTrack(rtc::scoped_refptr<AudioTrackInterface> track) override;
- bool RemoveTrack(rtc::scoped_refptr<VideoTrackInterface> track) override;
- rtc::scoped_refptr<AudioTrackInterface> FindAudioTrack(
+ bool AddTrack(scoped_refptr<AudioTrackInterface> track) override;
+ bool AddTrack(scoped_refptr<VideoTrackInterface> track) override;
+ bool RemoveTrack(scoped_refptr<AudioTrackInterface> track) override;
+ bool RemoveTrack(scoped_refptr<VideoTrackInterface> track) override;
+ scoped_refptr<AudioTrackInterface> FindAudioTrack(
const std::string& track_id) override;
- rtc::scoped_refptr<VideoTrackInterface> FindVideoTrack(
+ scoped_refptr<VideoTrackInterface> FindVideoTrack(
const std::string& track_id) override;
AudioTrackVector GetAudioTracks() override { return audio_tracks_; }
@@ -44,10 +44,10 @@
private:
template <typename TrackVector, typename Track>
- bool AddTrack(TrackVector* Tracks, rtc::scoped_refptr<Track> track);
+ bool AddTrack(TrackVector* Tracks, scoped_refptr<Track> track);
template <typename TrackVector>
bool RemoveTrack(TrackVector* Tracks,
- rtc::scoped_refptr<MediaStreamTrackInterface> track);
+ scoped_refptr<MediaStreamTrackInterface> track);
const std::string id_;
AudioTrackVector audio_tracks_;
diff --git a/pc/media_stream_observer.h b/pc/media_stream_observer.h
index 83bbd20..c60f766 100644
--- a/pc/media_stream_observer.h
+++ b/pc/media_stream_observer.h
@@ -39,7 +39,7 @@
void OnChanged() override;
private:
- rtc::scoped_refptr<MediaStreamInterface> stream_;
+ scoped_refptr<MediaStreamInterface> stream_;
AudioTrackVector cached_audio_tracks_;
VideoTrackVector cached_video_tracks_;
const std::function<void(AudioTrackInterface*, MediaStreamInterface*)>
diff --git a/pc/media_stream_proxy.h b/pc/media_stream_proxy.h
index 3e263bf..11ea22b 100644
--- a/pc/media_stream_proxy.h
+++ b/pc/media_stream_proxy.h
@@ -25,16 +25,16 @@
BYPASS_PROXY_CONSTMETHOD0(std::string, id)
PROXY_METHOD0(AudioTrackVector, GetAudioTracks)
PROXY_METHOD0(VideoTrackVector, GetVideoTracks)
-PROXY_METHOD1(rtc::scoped_refptr<AudioTrackInterface>,
+PROXY_METHOD1(scoped_refptr<AudioTrackInterface>,
FindAudioTrack,
const std::string&)
-PROXY_METHOD1(rtc::scoped_refptr<VideoTrackInterface>,
+PROXY_METHOD1(scoped_refptr<VideoTrackInterface>,
FindVideoTrack,
const std::string&)
-PROXY_METHOD1(bool, AddTrack, rtc::scoped_refptr<AudioTrackInterface>)
-PROXY_METHOD1(bool, AddTrack, rtc::scoped_refptr<VideoTrackInterface>)
-PROXY_METHOD1(bool, RemoveTrack, rtc::scoped_refptr<AudioTrackInterface>)
-PROXY_METHOD1(bool, RemoveTrack, rtc::scoped_refptr<VideoTrackInterface>)
+PROXY_METHOD1(bool, AddTrack, scoped_refptr<AudioTrackInterface>)
+PROXY_METHOD1(bool, AddTrack, scoped_refptr<VideoTrackInterface>)
+PROXY_METHOD1(bool, RemoveTrack, scoped_refptr<AudioTrackInterface>)
+PROXY_METHOD1(bool, RemoveTrack, scoped_refptr<VideoTrackInterface>)
PROXY_METHOD1(void, RegisterObserver, ObserverInterface*)
PROXY_METHOD1(void, UnregisterObserver, ObserverInterface*)
END_PROXY_MAP(MediaStream)
diff --git a/pc/media_stream_track_proxy.h b/pc/media_stream_track_proxy.h
index 4234d5e..8775ecd 100644
--- a/pc/media_stream_track_proxy.h
+++ b/pc/media_stream_track_proxy.h
@@ -33,7 +33,7 @@
PROXY_METHOD1(void, AddSink, AudioTrackSinkInterface*)
PROXY_METHOD1(void, RemoveSink, AudioTrackSinkInterface*)
PROXY_METHOD1(bool, GetSignalLevel, int*)
-PROXY_METHOD0(rtc::scoped_refptr<AudioProcessorInterface>, GetAudioProcessor)
+PROXY_METHOD0(scoped_refptr<AudioProcessorInterface>, GetAudioProcessor)
PROXY_METHOD1(bool, set_enabled, bool)
PROXY_METHOD1(void, RegisterObserver, ObserverInterface*)
PROXY_METHOD1(void, UnregisterObserver, ObserverInterface*)
diff --git a/pc/media_stream_unittest.cc b/pc/media_stream_unittest.cc
index fd1192e..9647080 100644
--- a/pc/media_stream_unittest.cc
+++ b/pc/media_stream_unittest.cc
@@ -25,8 +25,8 @@
static const char kVideoTrackId[] = "dummy_video_cam_1";
static const char kAudioTrackId[] = "dummy_microphone_1";
-using rtc::scoped_refptr;
using ::testing::Exactly;
+using webrtc::scoped_refptr;
namespace webrtc {
@@ -136,8 +136,8 @@
EXPECT_EQ(0u, stream_->GetVideoTracks().size());
EXPECT_EQ(0u, stream_->GetVideoTracks().size());
- EXPECT_FALSE(stream_->RemoveTrack(rtc::scoped_refptr<AudioTrackInterface>()));
- EXPECT_FALSE(stream_->RemoveTrack(rtc::scoped_refptr<VideoTrackInterface>()));
+ EXPECT_FALSE(stream_->RemoveTrack(scoped_refptr<AudioTrackInterface>()));
+ EXPECT_FALSE(stream_->RemoveTrack(scoped_refptr<VideoTrackInterface>()));
}
TEST_F(MediaStreamTest, ChangeVideoTrack) {
diff --git a/pc/peer_connection.cc b/pc/peer_connection.cc
index bc5b24e..a952650 100644
--- a/pc/peer_connection.cc
+++ b/pc/peer_connection.cc
@@ -124,19 +124,6 @@
#include "rtc_base/unique_id_generator.h"
#include "system_wrappers/include/metrics.h"
-using cricket::MediaContentDescription;
-using ::webrtc::ContentInfo;
-using ::webrtc::ContentInfos;
-using ::webrtc::MediaProtocolType;
-using ::webrtc::RidDescription;
-using ::webrtc::RidDirection;
-using ::webrtc::SessionDescription;
-using ::webrtc::SimulcastDescription;
-using ::webrtc::SimulcastLayer;
-using ::webrtc::SimulcastLayerList;
-using ::webrtc::StreamParams;
-using ::webrtc::TransportInfo;
-
namespace webrtc {
namespace {
@@ -371,7 +358,7 @@
}
void NoteServerUsage(UsagePattern& usage_pattern,
- const cricket::ServerAddresses& stun_servers,
+ const ServerAddresses& stun_servers,
const std::vector<RelayServerConfig>& turn_servers) {
if (!stun_servers.empty()) {
usage_pattern.NoteUsageEvent(UsageEvent::STUN_SERVER_ADDED);
@@ -392,7 +379,7 @@
IceTransportsType type;
BundlePolicy bundle_policy;
RtcpMuxPolicy rtcp_mux_policy;
- std::vector<rtc::scoped_refptr<RTCCertificate>> certificates;
+ std::vector<scoped_refptr<RTCCertificate>> certificates;
int ice_candidate_pool_size;
bool disable_ipv6_on_wifi;
int max_ipv6_networks;
@@ -423,7 +410,7 @@
std::optional<int> stun_candidate_keepalive_interval;
TurnCustomizer* turn_customizer;
SdpSemantics sdp_semantics;
- std::optional<rtc::AdapterType> network_preference;
+ std::optional<AdapterType> network_preference;
bool active_reset_srtp_params;
std::optional<CryptoOptions> crypto_options;
bool offer_extmap_allow_mixed;
@@ -504,14 +491,14 @@
return !(*this == o);
}
-rtc::scoped_refptr<PeerConnection> PeerConnection::Create(
+scoped_refptr<PeerConnection> PeerConnection::Create(
const Environment& env,
- rtc::scoped_refptr<ConnectionContext> context,
+ scoped_refptr<ConnectionContext> context,
const PeerConnectionFactoryInterface::Options& options,
std::unique_ptr<Call> call,
const PeerConnectionInterface::RTCConfiguration& configuration,
PeerConnectionDependencies& dependencies,
- const cricket::ServerAddresses& stun_servers,
+ const ServerAddresses& stun_servers,
const std::vector<RelayServerConfig>& turn_servers) {
RTC_DCHECK(IceConfig(configuration).IsValid().ok());
RTC_DCHECK(dependencies.observer);
@@ -523,7 +510,7 @@
bool dtls_enabled = DtlsEnabled(configuration, options, dependencies);
TRACE_EVENT0("webrtc", "PeerConnection::Create");
- return rtc::make_ref_counted<PeerConnection>(
+ return make_ref_counted<PeerConnection>(
configuration, env, context, options, is_unified_plan, std::move(call),
dependencies, stun_servers, turn_servers, dtls_enabled);
}
@@ -531,12 +518,12 @@
PeerConnection::PeerConnection(
const PeerConnectionInterface::RTCConfiguration& configuration,
const Environment& env,
- rtc::scoped_refptr<ConnectionContext> context,
+ scoped_refptr<ConnectionContext> context,
const PeerConnectionFactoryInterface::Options& options,
bool is_unified_plan,
std::unique_ptr<Call> call,
PeerConnectionDependencies& dependencies,
- const cricket::ServerAddresses& stun_servers,
+ const ServerAddresses& stun_servers,
const std::vector<RelayServerConfig>& turn_servers,
bool dtls_enabled)
: env_(env),
@@ -598,12 +585,12 @@
if (!IsUnifiedPlan()) {
rtp_manager_->transceivers()->Add(
RtpTransceiverProxyWithInternal<RtpTransceiver>::Create(
- signaling_thread(), rtc::make_ref_counted<RtpTransceiver>(
+ signaling_thread(), make_ref_counted<RtpTransceiver>(
webrtc::MediaType::AUDIO, context_.get(),
codec_lookup_helper_.get())));
rtp_manager_->transceivers()->Add(
RtpTransceiverProxyWithInternal<RtpTransceiver>::Create(
- signaling_thread(), rtc::make_ref_counted<RtpTransceiver>(
+ signaling_thread(), make_ref_counted<RtpTransceiver>(
webrtc::MediaType::VIDEO, context_.get(),
codec_lookup_helper_.get())));
}
@@ -679,7 +666,7 @@
}
JsepTransportController* PeerConnection::InitializeNetworkThread(
- const cricket::ServerAddresses& stun_servers,
+ const ServerAddresses& stun_servers,
const std::vector<RelayServerConfig>& turn_servers) {
RTC_DCHECK_RUN_ON(signaling_thread());
@@ -728,7 +715,7 @@
config.ice_transport_factory = ice_transport_factory_.get();
config.on_dtls_handshake_error_ =
- [weak_ptr = weak_factory_.GetWeakPtr()](rtc::SSLHandshakeError s) {
+ [weak_ptr = weak_factory_.GetWeakPtr()](SSLHandshakeError s) {
if (weak_ptr) {
weak_ptr->OnTransportControllerDtlsHandshakeError(s);
}
@@ -740,7 +727,7 @@
payload_type_picker_, std::move(config)));
transport_controller_->SubscribeIceConnectionState(
- [this](cricket::IceConnectionState s) {
+ [this](::webrtc::IceConnectionState s) {
RTC_DCHECK_RUN_ON(network_thread());
signaling_thread()->PostTask(
SafeTask(signaling_thread_safety_.flag(), [this, s]() {
@@ -777,7 +764,7 @@
});
transport_controller_->SubscribeIceCandidateGathered(
[this](const std::string& transport,
- const std::vector<cricket::Candidate>& candidates) {
+ const std::vector<Candidate>& candidates) {
RTC_DCHECK_RUN_ON(network_thread());
signaling_thread()->PostTask(
SafeTask(signaling_thread_safety_.flag(),
@@ -787,7 +774,7 @@
}));
});
transport_controller_->SubscribeIceCandidateError(
- [this](const cricket::IceCandidateErrorEvent& event) {
+ [this](const IceCandidateErrorEvent& event) {
RTC_DCHECK_RUN_ON(network_thread());
signaling_thread()->PostTask(
SafeTask(signaling_thread_safety_.flag(), [this, event = event]() {
@@ -796,7 +783,7 @@
}));
});
transport_controller_->SubscribeIceCandidatesRemoved(
- [this](const std::vector<cricket::Candidate>& c) {
+ [this](const std::vector<Candidate>& c) {
RTC_DCHECK_RUN_ON(network_thread());
signaling_thread()->PostTask(
SafeTask(signaling_thread_safety_.flag(), [this, c = c]() {
@@ -805,7 +792,7 @@
}));
});
transport_controller_->SubscribeIceCandidatePairChanged(
- [this](const cricket::CandidatePairChangeEvent& event) {
+ [this](const CandidatePairChangeEvent& event) {
RTC_DCHECK_RUN_ON(network_thread());
signaling_thread()->PostTask(
SafeTask(signaling_thread_safety_.flag(), [this, event = event]() {
@@ -822,7 +809,7 @@
return transport_controller_.get();
}
-rtc::scoped_refptr<StreamCollectionInterface> PeerConnection::local_streams() {
+scoped_refptr<StreamCollectionInterface> PeerConnection::local_streams() {
RTC_DCHECK_RUN_ON(signaling_thread());
RTC_CHECK(!IsUnifiedPlan()) << "local_streams is not available with Unified "
"Plan SdpSemantics. Please use GetSenders "
@@ -830,7 +817,7 @@
return sdp_handler_->local_streams();
}
-rtc::scoped_refptr<StreamCollectionInterface> PeerConnection::remote_streams() {
+scoped_refptr<StreamCollectionInterface> PeerConnection::remote_streams() {
RTC_DCHECK_RUN_ON(signaling_thread());
RTC_CHECK(!IsUnifiedPlan()) << "remote_streams is not available with Unified "
"Plan SdpSemantics. Please use GetReceivers "
@@ -860,21 +847,21 @@
sdp_handler_->RemoveStream(local_stream);
}
-RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+RTCErrorOr<scoped_refptr<RtpSenderInterface>> PeerConnection::AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids) {
return AddTrack(std::move(track), stream_ids, nullptr);
}
-RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+RTCErrorOr<scoped_refptr<RtpSenderInterface>> PeerConnection::AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::vector<RtpEncodingParameters>& init_send_encodings) {
return AddTrack(std::move(track), stream_ids, &init_send_encodings);
}
-RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+RTCErrorOr<scoped_refptr<RtpSenderInterface>> PeerConnection::AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::vector<RtpEncodingParameters>* init_send_encodings) {
RTC_DCHECK_RUN_ON(signaling_thread());
@@ -910,7 +897,7 @@
}
RTCError PeerConnection::RemoveTrackOrError(
- rtc::scoped_refptr<RtpSenderInterface> sender) {
+ scoped_refptr<RtpSenderInterface> sender) {
RTC_DCHECK_RUN_ON(signaling_thread());
if (!ConfiguredForMedia()) {
LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION,
@@ -956,15 +943,14 @@
return RTCError::OK();
}
-rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
PeerConnection::FindTransceiverBySender(
- rtc::scoped_refptr<RtpSenderInterface> sender) {
+ scoped_refptr<RtpSenderInterface> sender) {
return rtp_manager()->transceivers()->FindBySender(sender);
}
-RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
-PeerConnection::AddTransceiver(
- rtc::scoped_refptr<MediaStreamTrackInterface> track) {
+RTCErrorOr<scoped_refptr<RtpTransceiverInterface>>
+PeerConnection::AddTransceiver(scoped_refptr<MediaStreamTrackInterface> track) {
if (!ConfiguredForMedia()) {
LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION,
"Not configured for media");
@@ -973,10 +959,9 @@
return AddTransceiver(track, RtpTransceiverInit());
}
-RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
-PeerConnection::AddTransceiver(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
- const RtpTransceiverInit& init) {
+RTCErrorOr<scoped_refptr<RtpTransceiverInterface>>
+PeerConnection::AddTransceiver(scoped_refptr<MediaStreamTrackInterface> track,
+ const RtpTransceiverInit& init) {
RTC_DCHECK_RUN_ON(signaling_thread());
if (!ConfiguredForMedia()) {
LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION,
@@ -999,12 +984,12 @@
return AddTransceiver(media_type, track, init);
}
-RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
+RTCErrorOr<scoped_refptr<RtpTransceiverInterface>>
PeerConnection::AddTransceiver(webrtc::MediaType media_type) {
return AddTransceiver(media_type, RtpTransceiverInit());
}
-RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
+RTCErrorOr<scoped_refptr<RtpTransceiverInterface>>
PeerConnection::AddTransceiver(webrtc::MediaType media_type,
const RtpTransceiverInit& init) {
RTC_DCHECK_RUN_ON(signaling_thread());
@@ -1022,12 +1007,11 @@
return AddTransceiver(media_type, nullptr, init);
}
-RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
-PeerConnection::AddTransceiver(
- webrtc::MediaType media_type,
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
- const RtpTransceiverInit& init,
- bool update_negotiation_needed) {
+RTCErrorOr<scoped_refptr<RtpTransceiverInterface>>
+PeerConnection::AddTransceiver(webrtc::MediaType media_type,
+ scoped_refptr<MediaStreamTrackInterface> track,
+ const RtpTransceiverInit& init,
+ bool update_negotiation_needed) {
RTC_DCHECK_RUN_ON(signaling_thread());
if (!ConfiguredForMedia()) {
LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION,
@@ -1144,7 +1128,7 @@
sdp_handler_->UpdateNegotiationNeeded();
}
- return rtc::scoped_refptr<RtpTransceiverInterface>(transceiver);
+ return scoped_refptr<RtpTransceiverInterface>(transceiver);
}
void PeerConnection::OnNegotiationNeeded() {
@@ -1153,7 +1137,7 @@
sdp_handler_->UpdateNegotiationNeeded();
}
-rtc::scoped_refptr<RtpSenderInterface> PeerConnection::CreateSender(
+scoped_refptr<RtpSenderInterface> PeerConnection::CreateSender(
const std::string& kind,
const std::string& stream_id) {
RTC_DCHECK_RUN_ON(signaling_thread());
@@ -1182,7 +1166,7 @@
}
// TODO(steveanton): Move construction of the RtpSenders to RtpTransceiver.
- rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> new_sender;
+ scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> new_sender;
if (kind == MediaStreamTrackInterface::kAudioKind) {
auto audio_sender =
AudioRtpSender::Create(env_, worker_thread(), CreateRandomUuid(),
@@ -1207,10 +1191,10 @@
return new_sender;
}
-std::vector<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::GetSenders()
+std::vector<scoped_refptr<RtpSenderInterface>> PeerConnection::GetSenders()
const {
RTC_DCHECK_RUN_ON(signaling_thread());
- std::vector<rtc::scoped_refptr<RtpSenderInterface>> ret;
+ std::vector<scoped_refptr<RtpSenderInterface>> ret;
if (ConfiguredForMedia()) {
for (const auto& sender : rtp_manager()->GetSendersInternal()) {
ret.push_back(sender);
@@ -1219,10 +1203,10 @@
return ret;
}
-std::vector<rtc::scoped_refptr<RtpReceiverInterface>>
-PeerConnection::GetReceivers() const {
+std::vector<scoped_refptr<RtpReceiverInterface>> PeerConnection::GetReceivers()
+ const {
RTC_DCHECK_RUN_ON(signaling_thread());
- std::vector<rtc::scoped_refptr<RtpReceiverInterface>> ret;
+ std::vector<scoped_refptr<RtpReceiverInterface>> ret;
if (ConfiguredForMedia()) {
for (const auto& receiver : rtp_manager()->GetReceiversInternal()) {
ret.push_back(receiver);
@@ -1231,12 +1215,12 @@
return ret;
}
-std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>
+std::vector<scoped_refptr<RtpTransceiverInterface>>
PeerConnection::GetTransceivers() const {
RTC_DCHECK_RUN_ON(signaling_thread());
RTC_CHECK(IsUnifiedPlan())
<< "GetTransceivers is only supported with Unified Plan SdpSemantics.";
- std::vector<rtc::scoped_refptr<RtpTransceiverInterface>> all_transceivers;
+ std::vector<scoped_refptr<RtpTransceiverInterface>> all_transceivers;
if (ConfiguredForMedia()) {
for (const auto& transceiver : rtp_manager()->transceivers()->List()) {
all_transceivers.push_back(transceiver);
@@ -1280,19 +1264,19 @@
RTC_DCHECK(callback);
RTC_LOG_THREAD_BLOCK_COUNT();
stats_collector_->GetStatsReport(
- rtc::scoped_refptr<RTCStatsCollectorCallback>(callback));
+ scoped_refptr<RTCStatsCollectorCallback>(callback));
RTC_DCHECK_BLOCK_COUNT_NO_MORE_THAN(2);
}
void PeerConnection::GetStats(
- rtc::scoped_refptr<RtpSenderInterface> selector,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback) {
+ scoped_refptr<RtpSenderInterface> selector,
+ scoped_refptr<RTCStatsCollectorCallback> callback) {
TRACE_EVENT0("webrtc", "PeerConnection::GetStats");
RTC_DCHECK_RUN_ON(signaling_thread());
RTC_DCHECK(callback);
RTC_DCHECK(stats_collector_);
RTC_LOG_THREAD_BLOCK_COUNT();
- rtc::scoped_refptr<RtpSenderInternal> internal_sender;
+ scoped_refptr<RtpSenderInternal> internal_sender;
if (selector) {
for (const auto& proxy_transceiver :
rtp_manager()->transceivers()->List()) {
@@ -1317,14 +1301,14 @@
}
void PeerConnection::GetStats(
- rtc::scoped_refptr<RtpReceiverInterface> selector,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback) {
+ scoped_refptr<RtpReceiverInterface> selector,
+ scoped_refptr<RTCStatsCollectorCallback> callback) {
TRACE_EVENT0("webrtc", "PeerConnection::GetStats");
RTC_DCHECK_RUN_ON(signaling_thread());
RTC_DCHECK(callback);
RTC_DCHECK(stats_collector_);
RTC_LOG_THREAD_BLOCK_COUNT();
- rtc::scoped_refptr<RtpReceiverInternal> internal_receiver;
+ scoped_refptr<RtpReceiverInternal> internal_receiver;
if (selector) {
for (const auto& proxy_transceiver :
rtp_manager()->transceivers()->List()) {
@@ -1394,7 +1378,7 @@
"trickle");
}
-RTCErrorOr<rtc::scoped_refptr<DataChannelInterface>>
+RTCErrorOr<scoped_refptr<DataChannelInterface>>
PeerConnection::CreateDataChannelOrError(const std::string& label,
const DataChannelInit* config) {
RTC_DCHECK_RUN_ON(signaling_thread());
@@ -1413,14 +1397,14 @@
}
internal_config.fallback_ssl_role = sdp_handler_->GuessSslRole();
- RTCErrorOr<rtc::scoped_refptr<DataChannelInterface>> ret =
+ RTCErrorOr<scoped_refptr<DataChannelInterface>> ret =
data_channel_controller_.InternalCreateDataChannelWithProxy(
label, internal_config);
if (!ret.ok()) {
return ret.MoveError();
}
- rtc::scoped_refptr<DataChannelInterface> channel = ret.MoveValue();
+ scoped_refptr<DataChannelInterface> channel = ret.MoveValue();
// Check the onRenegotiationNeeded event (with plan-b backward compat)
if (configuration_.sdp_semantics == SdpSemantics::kUnifiedPlan ||
@@ -1458,7 +1442,7 @@
void PeerConnection::SetLocalDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
- rtc::scoped_refptr<SetLocalDescriptionObserverInterface> observer) {
+ scoped_refptr<SetLocalDescriptionObserverInterface> observer) {
RTC_DCHECK_RUN_ON(signaling_thread());
sdp_handler_->SetLocalDescription(std::move(desc), observer);
}
@@ -1470,7 +1454,7 @@
}
void PeerConnection::SetLocalDescription(
- rtc::scoped_refptr<SetLocalDescriptionObserverInterface> observer) {
+ scoped_refptr<SetLocalDescriptionObserverInterface> observer) {
RTC_DCHECK_RUN_ON(signaling_thread());
sdp_handler_->SetLocalDescription(observer);
}
@@ -1484,7 +1468,7 @@
void PeerConnection::SetRemoteDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
- rtc::scoped_refptr<SetRemoteDescriptionObserverInterface> observer) {
+ scoped_refptr<SetRemoteDescriptionObserverInterface> observer) {
RTC_DCHECK_RUN_ON(signaling_thread());
sdp_handler_->SetRemoteDescription(std::move(desc), observer);
}
@@ -1530,7 +1514,7 @@
}
// Parse ICE servers before hopping to network thread.
- cricket::ServerAddresses stun_servers;
+ ServerAddresses stun_servers;
std::vector<RelayServerConfig> turn_servers;
validate_error = ParseAndValidateIceServersFromConfiguration(
configuration, stun_servers, turn_servers);
@@ -1678,8 +1662,7 @@
audio_state->SetRecording(recording);
}
-void PeerConnection::AddAdaptationResource(
- rtc::scoped_refptr<Resource> resource) {
+void PeerConnection::AddAdaptationResource(scoped_refptr<Resource> resource) {
if (!worker_thread()->IsCurrent()) {
return worker_thread()->BlockingCall(
[this, resource]() { return AddAdaptationResource(resource); });
@@ -1726,14 +1709,14 @@
}));
}
-rtc::scoped_refptr<DtlsTransportInterface>
-PeerConnection::LookupDtlsTransportByMid(const std::string& mid) {
+scoped_refptr<DtlsTransportInterface> PeerConnection::LookupDtlsTransportByMid(
+ const std::string& mid) {
RTC_DCHECK_RUN_ON(network_thread());
return transport_controller_->LookupDtlsTransportByMid(mid);
}
-rtc::scoped_refptr<DtlsTransport>
-PeerConnection::LookupDtlsTransportByMidInternal(const std::string& mid) {
+scoped_refptr<DtlsTransport> PeerConnection::LookupDtlsTransportByMidInternal(
+ const std::string& mid) {
RTC_DCHECK_RUN_ON(signaling_thread());
// TODO(bugs.webrtc.org/9987): Avoid the thread jump.
// This might be done by caching the value on the signaling thread.
@@ -1743,8 +1726,7 @@
});
}
-rtc::scoped_refptr<SctpTransportInterface> PeerConnection::GetSctpTransport()
- const {
+scoped_refptr<SctpTransportInterface> PeerConnection::GetSctpTransport() const {
RTC_DCHECK_RUN_ON(network_thread());
if (!sctp_mid_n_)
return nullptr;
@@ -2140,7 +2122,7 @@
PeerConnection::InitializePortAllocatorResult
PeerConnection::InitializePortAllocator_n(
- const cricket::ServerAddresses& stun_servers,
+ const ServerAddresses& stun_servers,
const std::vector<RelayServerConfig>& turn_servers,
const RTCConfiguration& configuration) {
RTC_DCHECK_RUN_ON(network_thread());
@@ -2201,7 +2183,7 @@
}
bool PeerConnection::ReconfigurePortAllocator_n(
- const cricket::ServerAddresses& stun_servers,
+ const ServerAddresses& stun_servers,
const std::vector<RelayServerConfig>& turn_servers,
IceTransportsType type,
int candidate_pool_size,
@@ -2306,11 +2288,11 @@
return sctp_mid_s_;
}
-cricket::CandidateStatsList PeerConnection::GetPooledCandidateStats() const {
+CandidateStatsList PeerConnection::GetPooledCandidateStats() const {
RTC_DCHECK_RUN_ON(network_thread());
if (!network_thread_safety_->alive())
return {};
- cricket::CandidateStatsList candidate_stats_list;
+ CandidateStatsList candidate_stats_list;
port_allocator_->GetCandidateStatsFromPooledSessions(&candidate_stats_list);
return candidate_stats_list;
}
@@ -2340,7 +2322,7 @@
bool PeerConnection::GetLocalCertificate(
const std::string& transport_name,
- rtc::scoped_refptr<RTCCertificate>* certificate) {
+ scoped_refptr<RTCCertificate>* certificate) {
RTC_DCHECK_RUN_ON(network_thread());
if (!network_thread_safety_->alive() || !certificate) {
return false;
@@ -2368,9 +2350,9 @@
}
void PeerConnection::OnTransportControllerConnectionState(
- cricket::IceConnectionState state) {
+ ::webrtc::IceConnectionState state) {
switch (state) {
- case cricket::kIceConnectionConnecting:
+ case ::webrtc::kIceConnectionConnecting:
// If the current state is Connected or Completed, then there were
// writable channels but now there are not, so the next state must
// be Disconnected.
@@ -2385,10 +2367,10 @@
PeerConnectionInterface::kIceConnectionDisconnected);
}
break;
- case cricket::kIceConnectionFailed:
+ case ::webrtc::kIceConnectionFailed:
SetIceConnectionState(PeerConnectionInterface::kIceConnectionFailed);
break;
- case cricket::kIceConnectionConnected:
+ case ::webrtc::kIceConnectionConnected:
RTC_LOG(LS_INFO) << "Changing to ICE connected state because "
"all transports are writable.";
{
@@ -2408,7 +2390,7 @@
SetIceConnectionState(PeerConnectionInterface::kIceConnectionConnected);
NoteUsageEvent(UsageEvent::ICE_STATE_CONNECTED);
break;
- case cricket::kIceConnectionCompleted:
+ case ::webrtc::kIceConnectionCompleted:
RTC_LOG(LS_INFO) << "Changing to ICE completed state because "
"all transports are complete.";
if (ice_connection_state_ !=
@@ -2428,7 +2410,7 @@
void PeerConnection::OnTransportControllerCandidatesGathered(
const std::string& transport_name,
- const cricket::Candidates& candidates) {
+ const Candidates& candidates) {
// TODO(bugs.webrtc.org/12427): Expect this to come in on the network thread
// (not signaling as it currently does), handle appropriately.
int sdp_mline_index;
@@ -2439,7 +2421,7 @@
return;
}
- for (cricket::Candidates::const_iterator citer = candidates.begin();
+ for (Candidates::const_iterator citer = candidates.begin();
citer != candidates.end(); ++citer) {
// Use transport_name as the candidate media id.
std::unique_ptr<JsepIceCandidate> candidate(
@@ -2458,7 +2440,7 @@
void PeerConnection::OnTransportControllerCandidatesRemoved(
const std::vector<Candidate>& candidates) {
// Sanity check.
- for (const cricket::Candidate& candidate : candidates) {
+ for (const Candidate& candidate : candidates) {
if (candidate.transport_name().empty()) {
RTC_LOG(LS_ERROR) << "OnTransportControllerCandidatesRemoved: "
"empty content name in candidate "
@@ -2569,8 +2551,8 @@
if (bundle_groups_by_mid.empty())
return true;
- const cricket::ContentInfos& contents = desc->contents();
- for (cricket::ContentInfos::const_iterator citer = contents.begin();
+ const ContentInfos& contents = desc->contents();
+ for (ContentInfos::const_iterator citer = contents.begin();
citer != contents.end(); ++citer) {
const ContentInfo* content = (&*citer);
RTC_DCHECK(content != NULL);
@@ -2655,16 +2637,16 @@
const Candidate& candidate) {
RTC_DCHECK_RUN_ON(signaling_thread());
- if (candidate.network_type() != rtc::ADAPTER_TYPE_UNKNOWN) {
+ if (candidate.network_type() != ADAPTER_TYPE_UNKNOWN) {
RTC_DLOG(LS_WARNING) << "Using candidate with adapter type set - this "
"should only happen in test";
}
// Clear fields that do not make sense as remote candidates.
Candidate new_candidate(candidate);
- new_candidate.set_network_type(rtc::ADAPTER_TYPE_UNKNOWN);
+ new_candidate.set_network_type(ADAPTER_TYPE_UNKNOWN);
new_candidate.set_relay_protocol("");
- new_candidate.set_underlying_type_for_vpn(rtc::ADAPTER_TYPE_UNKNOWN);
+ new_candidate.set_underlying_type_for_vpn(ADAPTER_TYPE_UNKNOWN);
network_thread()->PostTask(SafeTask(
network_thread_safety_,
@@ -2783,9 +2765,8 @@
// for IPv4 and IPv6.
// static (no member state required)
void PeerConnection::ReportBestConnectionState(const TransportStats& stats) {
- for (const cricket::TransportChannelStats& channel_stats :
- stats.channel_stats) {
- for (const cricket::ConnectionInfo& connection_info :
+ for (const TransportChannelStats& channel_stats : stats.channel_stats) {
+ for (const ConnectionInfo& connection_info :
channel_stats.ice_transport_stats.connection_infos) {
if (!connection_info.best_connection) {
continue;
@@ -2899,7 +2880,7 @@
bool PeerConnection::OnTransportChanged(
const std::string& mid,
RtpTransportInternal* rtp_transport,
- rtc::scoped_refptr<DtlsTransport> dtls_transport,
+ scoped_refptr<DtlsTransport> dtls_transport,
DataChannelTransportInterface* data_channel_transport) {
RTC_DCHECK_RUN_ON(network_thread());
bool ret = true;
@@ -2941,7 +2922,7 @@
network_thread()->PostTask(
SafeTask(network_thread_safety_, [this, mid = *sctp_mid_s_, options] {
- rtc::scoped_refptr<SctpTransport> sctp_transport =
+ scoped_refptr<SctpTransport> sctp_transport =
transport_controller_n()->GetSctpTransport(mid);
if (sctp_transport)
sctp_transport->Start(options);
@@ -2997,12 +2978,11 @@
});
}
-std::function<void(const rtc::CopyOnWriteBuffer& packet,
+std::function<void(const webrtc::CopyOnWriteBuffer& packet,
int64_t packet_time_us)>
PeerConnection::InitializeRtcpCallback() {
RTC_DCHECK_RUN_ON(network_thread());
- return [this](const rtc::CopyOnWriteBuffer& packet,
- int64_t /*packet_time_us*/) {
+ return [this](const CopyOnWriteBuffer& packet, int64_t /*packet_time_us*/) {
worker_thread()->PostTask(SafeTask(worker_thread_safety_, [this, packet]() {
call_ptr_->Receiver()->DeliverRtcpPacket(packet);
}));
diff --git a/pc/peer_connection.h b/pc/peer_connection.h
index c5254e0..eeea50f 100644
--- a/pc/peer_connection.h
+++ b/pc/peer_connection.h
@@ -116,58 +116,57 @@
//
// Note that the function takes ownership of dependencies, and will
// either use them or release them, whether it succeeds or fails.
- static rtc::scoped_refptr<PeerConnection> Create(
+ static scoped_refptr<PeerConnection> Create(
const Environment& env,
- rtc::scoped_refptr<ConnectionContext> context,
+ scoped_refptr<ConnectionContext> context,
const PeerConnectionFactoryInterface::Options& options,
std::unique_ptr<Call> call,
const PeerConnectionInterface::RTCConfiguration& configuration,
PeerConnectionDependencies& dependencies,
- const cricket::ServerAddresses& stun_servers,
+ const ServerAddresses& stun_servers,
const std::vector<RelayServerConfig>& turn_servers);
- rtc::scoped_refptr<StreamCollectionInterface> local_streams() override;
- rtc::scoped_refptr<StreamCollectionInterface> remote_streams() override;
+ scoped_refptr<StreamCollectionInterface> local_streams() override;
+ scoped_refptr<StreamCollectionInterface> remote_streams() override;
bool AddStream(MediaStreamInterface* local_stream) override;
void RemoveStream(MediaStreamInterface* local_stream) override;
- RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ RTCErrorOr<scoped_refptr<RtpSenderInterface>> AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids) override;
- RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ RTCErrorOr<scoped_refptr<RtpSenderInterface>> AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::vector<RtpEncodingParameters>& init_send_encodings) override;
- RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ RTCErrorOr<scoped_refptr<RtpSenderInterface>> AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::vector<RtpEncodingParameters>* init_send_encodings);
RTCError RemoveTrackOrError(
- rtc::scoped_refptr<RtpSenderInterface> sender) override;
+ scoped_refptr<RtpSenderInterface> sender) override;
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
- rtc::scoped_refptr<MediaStreamTrackInterface> track) override;
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+ scoped_refptr<MediaStreamTrackInterface> track) override;
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+ scoped_refptr<MediaStreamTrackInterface> track,
const RtpTransceiverInit& init) override;
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
webrtc::MediaType media_type) override;
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
webrtc::MediaType media_type,
const RtpTransceiverInit& init) override;
- rtc::scoped_refptr<RtpSenderInterface> CreateSender(
+ scoped_refptr<RtpSenderInterface> CreateSender(
const std::string& kind,
const std::string& stream_id) override;
- std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders()
+ std::vector<scoped_refptr<RtpSenderInterface>> GetSenders() const override;
+ std::vector<scoped_refptr<RtpReceiverInterface>> GetReceivers()
const override;
- std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers()
- const override;
- std::vector<rtc::scoped_refptr<RtpTransceiverInterface>> GetTransceivers()
+ std::vector<scoped_refptr<RtpTransceiverInterface>> GetTransceivers()
const override;
- RTCErrorOr<rtc::scoped_refptr<DataChannelInterface>> CreateDataChannelOrError(
+ RTCErrorOr<scoped_refptr<DataChannelInterface>> CreateDataChannelOrError(
const std::string& label,
const DataChannelInit* config) override;
// WARNING: LEGACY. See peerconnectioninterface.h
@@ -176,12 +175,10 @@
StatsOutputLevel level) override;
// Spec-complaint GetStats(). See peerconnectioninterface.h
void GetStats(RTCStatsCollectorCallback* callback) override;
- void GetStats(
- rtc::scoped_refptr<RtpSenderInterface> selector,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback) override;
- void GetStats(
- rtc::scoped_refptr<RtpReceiverInterface> selector,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback) override;
+ void GetStats(scoped_refptr<RtpSenderInterface> selector,
+ scoped_refptr<RTCStatsCollectorCallback> callback) override;
+ void GetStats(scoped_refptr<RtpReceiverInterface> selector,
+ scoped_refptr<RTCStatsCollectorCallback> callback) override;
void ClearStatsCache() override;
SignalingState signaling_state() override;
@@ -214,11 +211,9 @@
void SetLocalDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
- rtc::scoped_refptr<SetLocalDescriptionObserverInterface> observer)
- override;
+ scoped_refptr<SetLocalDescriptionObserverInterface> observer) override;
void SetLocalDescription(
- rtc::scoped_refptr<SetLocalDescriptionObserverInterface> observer)
- override;
+ scoped_refptr<SetLocalDescriptionObserverInterface> observer) override;
// TODO(https://crbug.com/webrtc/11798): Delete these methods in favor of the
// ones taking SetLocalDescriptionObserverInterface as argument.
void SetLocalDescription(SetSessionDescriptionObserver* observer,
@@ -227,8 +222,7 @@
void SetRemoteDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
- rtc::scoped_refptr<SetRemoteDescriptionObserverInterface> observer)
- override;
+ scoped_refptr<SetRemoteDescriptionObserverInterface> observer) override;
// TODO(https://crbug.com/webrtc/11798): Delete this methods in favor of the
// ones taking SetRemoteDescriptionObserverInterface as argument.
void SetRemoteDescription(SetSessionDescriptionObserver* observer,
@@ -249,14 +243,14 @@
void SetAudioPlayout(bool playout) override;
void SetAudioRecording(bool recording) override;
- rtc::scoped_refptr<DtlsTransportInterface> LookupDtlsTransportByMid(
+ scoped_refptr<DtlsTransportInterface> LookupDtlsTransportByMid(
const std::string& mid) override;
- rtc::scoped_refptr<DtlsTransport> LookupDtlsTransportByMidInternal(
+ scoped_refptr<DtlsTransport> LookupDtlsTransportByMidInternal(
const std::string& mid);
- rtc::scoped_refptr<SctpTransportInterface> GetSctpTransport() const override;
+ scoped_refptr<SctpTransportInterface> GetSctpTransport() const override;
- void AddAdaptationResource(rtc::scoped_refptr<Resource> resource) override;
+ void AddAdaptationResource(scoped_refptr<Resource> resource) override;
bool StartRtcEventLog(std::unique_ptr<RtcEventLogOutput> output,
int64_t output_period_ms) override;
@@ -282,8 +276,7 @@
return sdp_handler_->initial_offerer();
}
- std::vector<
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
+ std::vector<scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
GetTransceiversInternal() const override {
RTC_DCHECK_RUN_ON(signaling_thread());
if (!ConfiguredForMedia()) {
@@ -297,16 +290,15 @@
std::optional<std::string> sctp_transport_name() const override;
std::optional<std::string> sctp_mid() const override;
- cricket::CandidateStatsList GetPooledCandidateStats() const override;
+ CandidateStatsList GetPooledCandidateStats() const override;
std::map<std::string, TransportStats> GetTransportStatsByNames(
const std::set<std::string>& transport_names) override;
Call::Stats GetCallStats() override;
std::optional<AudioDeviceModule::Stats> GetAudioDeviceStats() override;
- bool GetLocalCertificate(
- const std::string& transport_name,
- rtc::scoped_refptr<RTCCertificate>* certificate) override;
+ bool GetLocalCertificate(const std::string& transport_name,
+ scoped_refptr<RTCCertificate>* certificate) override;
std::unique_ptr<SSLCertChain> GetRemoteSSLCertChain(
const std::string& transport_name) override;
bool IceRestartPending(const std::string& content_name) const override;
@@ -418,9 +410,9 @@
// Internal implementation for AddTransceiver family of methods. If
// `fire_callback` is set, fires OnRenegotiationNeeded callback if successful.
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
webrtc::MediaType media_type,
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ scoped_refptr<MediaStreamTrackInterface> track,
const RtpTransceiverInit& init,
bool fire_callback = true) override;
@@ -469,15 +461,15 @@
}
protected:
- // Available for rtc::scoped_refptr creation
+ // Available for webrtc::scoped_refptr creation
PeerConnection(const PeerConnectionInterface::RTCConfiguration& configuration,
const Environment& env,
- rtc::scoped_refptr<ConnectionContext> context,
+ scoped_refptr<ConnectionContext> context,
const PeerConnectionFactoryInterface::Options& options,
bool is_unified_plan,
std::unique_ptr<Call> call,
PeerConnectionDependencies& dependencies,
- const cricket::ServerAddresses& stun_servers,
+ const ServerAddresses& stun_servers,
const std::vector<RelayServerConfig>& turn_servers,
bool dtls_enabled);
@@ -489,13 +481,13 @@
// InitializeTransportController_n). The return value of this function is used
// to set the initial value of `transport_controller_copy_`.
JsepTransportController* InitializeNetworkThread(
- const cricket::ServerAddresses& stun_servers,
+ const ServerAddresses& stun_servers,
const std::vector<RelayServerConfig>& turn_servers);
JsepTransportController* InitializeTransportController_n(
const RTCConfiguration& configuration) RTC_RUN_ON(network_thread());
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
- FindTransceiverBySender(rtc::scoped_refptr<RtpSenderInterface> sender)
+ scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+ FindTransceiverBySender(scoped_refptr<RtpSenderInterface> sender)
RTC_RUN_ON(signaling_thread());
void SetStandardizedIceConnectionState(
@@ -532,13 +524,13 @@
bool enable_ipv6;
};
InitializePortAllocatorResult InitializePortAllocator_n(
- const cricket::ServerAddresses& stun_servers,
+ const ServerAddresses& stun_servers,
const std::vector<RelayServerConfig>& turn_servers,
const RTCConfiguration& configuration);
// Called when SetConfiguration is called to apply the supported subset
// of the configuration on the network thread.
bool ReconfigurePortAllocator_n(
- const cricket::ServerAddresses& stun_servers,
+ const ServerAddresses& stun_servers,
const std::vector<RelayServerConfig>& turn_servers,
IceTransportsType type,
int candidate_pool_size,
@@ -570,7 +562,7 @@
RTC_RUN_ON(signaling_thread());
// JsepTransportController signal handlers.
- void OnTransportControllerConnectionState(cricket::IceConnectionState state)
+ void OnTransportControllerConnectionState(::webrtc::IceConnectionState state)
RTC_RUN_ON(signaling_thread());
void OnTransportControllerGatheringState(::webrtc::IceGatheringState state)
RTC_RUN_ON(signaling_thread());
@@ -613,12 +605,12 @@
bool OnTransportChanged(
const std::string& mid,
RtpTransportInternal* rtp_transport,
- rtc::scoped_refptr<DtlsTransport> dtls_transport,
+ scoped_refptr<DtlsTransport> dtls_transport,
DataChannelTransportInterface* data_channel_transport) override;
void SetSctpTransportName(std::string sctp_transport_name);
- std::function<void(const rtc::CopyOnWriteBuffer& packet,
+ std::function<void(const webrtc::CopyOnWriteBuffer& packet,
int64_t packet_time_us)>
InitializeRtcpCallback();
@@ -628,7 +620,7 @@
bool CanAttemptDtlsStunPiggybacking(const RTCConfiguration& configuration);
const Environment env_;
- const rtc::scoped_refptr<ConnectionContext> context_;
+ const scoped_refptr<ConnectionContext> context_;
const PeerConnectionFactoryInterface::Options options_;
PeerConnectionObserver* observer_ RTC_GUARDED_BY(signaling_thread()) =
nullptr;
@@ -671,8 +663,8 @@
// its own thread safety.
std::unique_ptr<Call> call_ RTC_GUARDED_BY(worker_thread());
ScopedTaskSafety signaling_thread_safety_;
- rtc::scoped_refptr<PendingTaskSafetyFlag> network_thread_safety_;
- rtc::scoped_refptr<PendingTaskSafetyFlag> worker_thread_safety_;
+ scoped_refptr<PendingTaskSafetyFlag> network_thread_safety_;
+ scoped_refptr<PendingTaskSafetyFlag> worker_thread_safety_;
// Points to the same thing as `call_`. Since it's const, we may read the
// pointer from any thread.
@@ -682,7 +674,7 @@
std::unique_ptr<LegacyStatsCollector> legacy_stats_
RTC_GUARDED_BY(signaling_thread()); // A pointer is passed to senders_
- rtc::scoped_refptr<RTCStatsCollector> stats_collector_
+ scoped_refptr<RTCStatsCollector> stats_collector_
RTC_GUARDED_BY(signaling_thread());
const std::string session_id_;
diff --git a/pc/peer_connection_adaptation_integrationtest.cc b/pc/peer_connection_adaptation_integrationtest.cc
index 47e2a26..da4f387 100644
--- a/pc/peer_connection_adaptation_integrationtest.cc
+++ b/pc/peer_connection_adaptation_integrationtest.cc
@@ -40,13 +40,13 @@
namespace webrtc {
struct TrackWithPeriodicSource {
- rtc::scoped_refptr<VideoTrackInterface> track;
- rtc::scoped_refptr<FakePeriodicVideoTrackSource> periodic_track_source;
+ scoped_refptr<VideoTrackInterface> track;
+ scoped_refptr<FakePeriodicVideoTrackSource> periodic_track_source;
};
// Performs an O/A exchange and waits until the signaling state is stable again.
-void Negotiate(rtc::scoped_refptr<PeerConnectionTestWrapper> caller,
- rtc::scoped_refptr<PeerConnectionTestWrapper> callee) {
+void Negotiate(scoped_refptr<PeerConnectionTestWrapper> caller,
+ scoped_refptr<PeerConnectionTestWrapper> callee) {
// Wire up callbacks and listeners such that a full O/A is performed in
// response to CreateOffer().
PeerConnectionTestWrapper::Connect(caller.get(), callee.get());
@@ -55,12 +55,12 @@
}
TrackWithPeriodicSource CreateTrackWithPeriodicSource(
- rtc::scoped_refptr<PeerConnectionFactoryInterface> factory) {
+ scoped_refptr<PeerConnectionFactoryInterface> factory) {
FakePeriodicVideoSource::Config periodic_track_source_config;
periodic_track_source_config.frame_interval_ms = 100;
periodic_track_source_config.timestamp_offset_ms = TimeMillis();
- rtc::scoped_refptr<FakePeriodicVideoTrackSource> periodic_track_source =
- rtc::make_ref_counted<FakePeriodicVideoTrackSource>(
+ scoped_refptr<FakePeriodicVideoTrackSource> periodic_track_source =
+ make_ref_counted<FakePeriodicVideoTrackSource>(
periodic_track_source_config, /* remote */ false);
TrackWithPeriodicSource track_with_source;
track_with_source.track =
@@ -74,7 +74,7 @@
// have yet to reflect the overuse signal. Used together with EXPECT_TRUE_WAIT
// to "spam overuse until a change is observed".
VideoSinkWants TriggerOveruseAndGetSinkWants(
- rtc::scoped_refptr<FakeResource> fake_resource,
+ scoped_refptr<FakeResource> fake_resource,
const FakePeriodicVideoSource& source) {
fake_resource->SetUsageState(ResourceUsageState::kOveruse);
return source.wants();
@@ -90,10 +90,9 @@
RTC_CHECK(worker_thread_->Start());
}
- rtc::scoped_refptr<PeerConnectionTestWrapper> CreatePcWrapper(
- const char* name) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> pc_wrapper =
- rtc::make_ref_counted<PeerConnectionTestWrapper>(
+ scoped_refptr<PeerConnectionTestWrapper> CreatePcWrapper(const char* name) {
+ scoped_refptr<PeerConnectionTestWrapper> pc_wrapper =
+ make_ref_counted<PeerConnectionTestWrapper>(
name, &virtual_socket_server_, network_thread_.get(),
worker_thread_.get());
PeerConnectionInterface::RTCConfiguration config;
diff --git a/pc/peer_connection_bundle_unittest.cc b/pc/peer_connection_bundle_unittest.cc
index 2587519..e0f5643 100644
--- a/pc/peer_connection_bundle_unittest.cc
+++ b/pc/peer_connection_bundle_unittest.cc
@@ -230,9 +230,8 @@
auto observer = std::make_unique<MockPeerConnectionObserver>();
RTCConfiguration modified_config = config;
- modified_config.set_port_allocator_flags(
- cricket::PORTALLOCATOR_DISABLE_TCP |
- cricket::PORTALLOCATOR_DISABLE_RELAY);
+ modified_config.set_port_allocator_flags(PORTALLOCATOR_DISABLE_TCP |
+ PORTALLOCATOR_DISABLE_RELAY);
modified_config.sdp_semantics = sdp_semantics_;
auto result = pc_factory->CreatePeerConnectionOrError(
modified_config, PeerConnectionDependencies(observer.get()));
@@ -830,17 +829,17 @@
// Removing the second MID from the BUNDLE group.
auto* old_bundle_group =
- offer->description()->GetGroupByName(cricket::GROUP_TYPE_BUNDLE);
+ offer->description()->GetGroupByName(webrtc::GROUP_TYPE_BUNDLE);
std::string first_mid = old_bundle_group->content_names()[0];
std::string third_mid = old_bundle_group->content_names()[2];
- cricket::ContentGroup new_bundle_group(cricket::GROUP_TYPE_BUNDLE);
+ webrtc::ContentGroup new_bundle_group(webrtc::GROUP_TYPE_BUNDLE);
new_bundle_group.AddContentName(first_mid);
new_bundle_group.AddContentName(third_mid);
// Reject the entire new bundle group.
re_offer->description()->contents()[0].rejected = true;
re_offer->description()->contents()[2].rejected = true;
- re_offer->description()->RemoveGroupByName(cricket::GROUP_TYPE_BUNDLE);
+ re_offer->description()->RemoveGroupByName(webrtc::GROUP_TYPE_BUNDLE);
re_offer->description()->AddGroup(new_bundle_group);
EXPECT_TRUE(caller->SetLocalDescription(std::move(re_offer)));
diff --git a/pc/peer_connection_callsetup_perf_tests.cc b/pc/peer_connection_callsetup_perf_tests.cc
index 3ea9096..c8c4ff5 100644
--- a/pc/peer_connection_callsetup_perf_tests.cc
+++ b/pc/peer_connection_callsetup_perf_tests.cc
@@ -58,10 +58,10 @@
: public ::testing::TestWithParam<
std::tuple</*field_trials=*/std::string,
/*signal_candidates_from_client=*/bool,
- /*dtls_role=*/cricket::ConnectionRole>> {
+ /*dtls_role=*/ConnectionRole>> {
public:
PeerConnectionDataChannelOpenTest()
- : background_thread_(std::make_unique<rtc::Thread>(&vss_)) {
+ : background_thread_(std::make_unique<Thread>(&vss_)) {
RTC_CHECK(background_thread_->Start());
// Delay is set to 50ms so we get a 100ms RTT.
vss_.set_delay_mean(/*delay_ms=*/50);
@@ -79,30 +79,28 @@
}
void SignalIceCandidates(
- rtc::scoped_refptr<PeerConnectionTestWrapper> from_pc_wrapper,
- rtc::scoped_refptr<PeerConnectionTestWrapper> to_pc_wrapper) {
+ scoped_refptr<PeerConnectionTestWrapper> from_pc_wrapper,
+ scoped_refptr<PeerConnectionTestWrapper> to_pc_wrapper) {
from_pc_wrapper->SignalOnIceCandidateReady.connect(
to_pc_wrapper.get(), &PeerConnectionTestWrapper::AddIceCandidate);
}
- void Negotiate(
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper,
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper,
- cricket::ConnectionRole remote_role) {
+ void Negotiate(scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper,
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper,
+ ConnectionRole remote_role) {
std::unique_ptr<SessionDescriptionInterface> offer =
CreateOffer(local_pc_wrapper);
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> p1 =
+ scoped_refptr<MockSetSessionDescriptionObserver> p1 =
SetLocalDescription(local_pc_wrapper, offer.get());
std::unique_ptr<SessionDescriptionInterface> modified_offer =
offer->Clone();
// Modify offer role to get desired remote role.
- if (remote_role == cricket::CONNECTIONROLE_PASSIVE) {
+ if (remote_role == CONNECTIONROLE_PASSIVE) {
auto& transport_infos = modified_offer->description()->transport_infos();
ASSERT_TRUE(!transport_infos.empty());
- transport_infos[0].description.connection_role =
- cricket::CONNECTIONROLE_ACTIVE;
+ transport_infos[0].description.connection_role = CONNECTIONROLE_ACTIVE;
}
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> p2 =
+ scoped_refptr<MockSetSessionDescriptionObserver> p2 =
SetRemoteDescription(remote_pc_wrapper, modified_offer.get());
EXPECT_TRUE(Await({p1, p2}));
std::unique_ptr<SessionDescriptionInterface> answer =
@@ -112,8 +110,7 @@
EXPECT_TRUE(Await({p1, p2}));
}
- bool WaitForDataChannelOpen(
- rtc::scoped_refptr<webrtc::DataChannelInterface> dc) {
+ bool WaitForDataChannelOpen(scoped_refptr<webrtc::DataChannelInterface> dc) {
return WaitUntil(
[&] {
return dc->state() == DataChannelInterface::DataState::kOpen;
@@ -124,9 +121,8 @@
protected:
std::unique_ptr<SessionDescriptionInterface> CreateOffer(
- rtc::scoped_refptr<PeerConnectionTestWrapper> pc_wrapper) {
- auto observer =
- rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ scoped_refptr<PeerConnectionTestWrapper> pc_wrapper) {
+ auto observer = make_ref_counted<MockCreateSessionDescriptionObserver>();
pc_wrapper->pc()->CreateOffer(observer.get(), {});
EXPECT_THAT(WaitUntil([&] { return observer->called(); }, IsTrue()),
IsRtcOk());
@@ -134,28 +130,27 @@
}
std::unique_ptr<SessionDescriptionInterface> CreateAnswer(
- rtc::scoped_refptr<PeerConnectionTestWrapper> pc_wrapper) {
- auto observer =
- rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ scoped_refptr<PeerConnectionTestWrapper> pc_wrapper) {
+ auto observer = make_ref_counted<MockCreateSessionDescriptionObserver>();
pc_wrapper->pc()->CreateAnswer(observer.get(), {});
EXPECT_THAT(WaitUntil([&] { return observer->called(); }, IsTrue()),
IsRtcOk());
return observer->MoveDescription();
}
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> SetLocalDescription(
- rtc::scoped_refptr<PeerConnectionTestWrapper> pc_wrapper,
+ scoped_refptr<MockSetSessionDescriptionObserver> SetLocalDescription(
+ scoped_refptr<PeerConnectionTestWrapper> pc_wrapper,
SessionDescriptionInterface* sdp) {
- auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockSetSessionDescriptionObserver>();
pc_wrapper->pc()->SetLocalDescription(
observer.get(), CloneSessionDescription(sdp).release());
return observer;
}
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> SetRemoteDescription(
- rtc::scoped_refptr<PeerConnectionTestWrapper> pc_wrapper,
+ scoped_refptr<MockSetSessionDescriptionObserver> SetRemoteDescription(
+ scoped_refptr<PeerConnectionTestWrapper> pc_wrapper,
SessionDescriptionInterface* sdp) {
- auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockSetSessionDescriptionObserver>();
pc_wrapper->pc()->SetRemoteDescription(
observer.get(), CloneSessionDescription(sdp).release());
return observer;
@@ -165,8 +160,8 @@
// the offer it is important to SetLocalDescription() and
// SetRemoteDescription() are kicked off without awaiting in-between. This
// helper is used to await multiple observers.
- bool Await(std::vector<rtc::scoped_refptr<MockSetSessionDescriptionObserver>>
- observers) {
+ bool Await(
+ std::vector<scoped_refptr<MockSetSessionDescriptionObserver>> observers) {
for (auto& observer : observers) {
auto result = WaitUntil([&] { return observer->called(); }, IsTrue());
@@ -177,20 +172,20 @@
return true;
}
- rtc::VirtualSocketServer vss_;
- std::unique_ptr<rtc::Thread> background_thread_;
+ VirtualSocketServer vss_;
+ std::unique_ptr<Thread> background_thread_;
};
TEST_P(PeerConnectionDataChannelOpenTest, OpenAtCaller) {
std::string trials = std::get<0>(GetParam());
bool skip_candidates_from_caller = std::get<1>(GetParam());
- cricket::ConnectionRole role = std::get<2>(GetParam());
+ ConnectionRole role = std::get<2>(GetParam());
std::string role_string;
- ASSERT_TRUE(cricket::ConnectionRoleToString(role, &role_string));
+ ASSERT_TRUE(ConnectionRoleToString(role, &role_string));
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper =
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper =
CreatePc(FieldTrials::CreateNoGlobal(trials));
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper =
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper =
CreatePc(FieldTrials::CreateNoGlobal(trials));
if (!skip_candidates_from_caller) {
@@ -200,12 +195,12 @@
auto dc = local_pc_wrapper->CreateDataChannel("test", {});
Negotiate(local_pc_wrapper, remote_pc_wrapper, role);
- uint64_t start_time = rtc::TimeNanos();
+ uint64_t start_time = TimeNanos();
EXPECT_TRUE(WaitForDataChannelOpen(dc));
- uint64_t open_time = rtc::TimeNanos();
+ uint64_t open_time = TimeNanos();
uint64_t setup_time = open_time - start_time;
- double setup_time_millis = setup_time / rtc::kNumNanosecsPerMillisec;
+ double setup_time_millis = setup_time / kNumNanosecsPerMillisec;
std::string test_description =
"emulate_server=" + absl::StrCat(skip_candidates_from_caller) +
"/dtls_role=" + role_string + "/trials=" + trials;
@@ -236,10 +231,10 @@
testing::Values(
// Default, other side will send
// the DTLS handshake.
- cricket::CONNECTIONROLE_ACTIVE,
+ CONNECTIONROLE_ACTIVE,
// Local side will send the DTLS
// handshake.
- cricket::CONNECTIONROLE_PASSIVE)));
+ CONNECTIONROLE_PASSIVE)));
#endif // WEBRTC_HAVE_SCTP
diff --git a/pc/peer_connection_crypto_unittest.cc b/pc/peer_connection_crypto_unittest.cc
index 0de4aec..fd0f3f6 100644
--- a/pc/peer_connection_crypto_unittest.cc
+++ b/pc/peer_connection_crypto_unittest.cc
@@ -156,7 +156,7 @@
std::unique_ptr<VirtualSocketServer> vss_;
AutoSocketServerThread main_;
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
const SdpSemantics sdp_semantics_;
};
@@ -167,10 +167,10 @@
}
SdpContentPredicate HaveProtocol(const std::string& protocol) {
- return [protocol](const cricket::ContentInfo* content,
- const cricket::TransportInfo* transport) {
- return content->media_description()->protocol() == protocol;
- };
+ return
+ [protocol](const ContentInfo* content, const TransportInfo* transport) {
+ return content->media_description()->protocol() == protocol;
+ };
}
class PeerConnectionCryptoTest
@@ -385,11 +385,10 @@
ASSERT_EQ(fake_certificate_generator->generated_certificates(), 0);
fake_certificate_generator->set_should_wait(false);
}
- std::vector<rtc::scoped_refptr<MockCreateSessionDescriptionObserver>>
- observers;
+ std::vector<scoped_refptr<MockCreateSessionDescriptionObserver>> observers;
for (size_t i = 0; i < concurrent_calls_; i++) {
- rtc::scoped_refptr<MockCreateSessionDescriptionObserver> observer =
- rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ scoped_refptr<MockCreateSessionDescriptionObserver> observer =
+ make_ref_counted<MockCreateSessionDescriptionObserver>();
observers.push_back(observer);
if (sdp_type_ == SdpType::kOffer) {
pc->pc()->CreateOffer(observer.get(),
diff --git a/pc/peer_connection_data_channel_unittest.cc b/pc/peer_connection_data_channel_unittest.cc
index 79fc4d0..47a85a5 100644
--- a/pc/peer_connection_data_channel_unittest.cc
+++ b/pc/peer_connection_data_channel_unittest.cc
@@ -117,7 +117,7 @@
auto factory_deps = CreatePeerConnectionFactoryDependencies();
FakeSctpTransportFactory* fake_sctp_transport_factory =
static_cast<FakeSctpTransportFactory*>(factory_deps.sctp_factory.get());
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory =
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory =
CreateModularPeerConnectionFactory(std::move(factory_deps));
pc_factory->SetOptions(factory_options);
auto observer = std::make_unique<MockPeerConnectionObserver>();
@@ -183,7 +183,7 @@
ASSERT_TRUE(caller->SetLocalDescription(caller->CreateOffer()));
EXPECT_TRUE(caller->sctp_transport_factory()->last_fake_sctp_transport());
- rtc::scoped_refptr<SctpTransportInterface> sctp_transport =
+ scoped_refptr<SctpTransportInterface> sctp_transport =
caller->GetInternalPeerConnection()->GetSctpTransport();
caller.reset();
diff --git a/pc/peer_connection_encodings_integrationtest.cc b/pc/peer_connection_encodings_integrationtest.cc
index db43ca7..2834f4c 100644
--- a/pc/peer_connection_encodings_integrationtest.cc
+++ b/pc/peer_connection_encodings_integrationtest.cc
@@ -203,7 +203,7 @@
};
std::string GetCurrentCodecMimeType(
- rtc::scoped_refptr<const RTCStatsReport> report,
+ scoped_refptr<const RTCStatsReport> report,
const RTCOutboundRtpStreamStats& outbound_rtp) {
return outbound_rtp.codec_id.has_value()
? *report->GetAs<RTCCodecStats>(*outbound_rtp.codec_id)->mime_type
@@ -240,24 +240,23 @@
return pc_wrapper;
}
- rtc::scoped_refptr<RtpTransceiverInterface> AddTransceiverWithSimulcastLayers(
- rtc::scoped_refptr<PeerConnectionTestWrapper> local,
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote,
+ scoped_refptr<RtpTransceiverInterface> AddTransceiverWithSimulcastLayers(
+ scoped_refptr<PeerConnectionTestWrapper> local,
+ scoped_refptr<PeerConnectionTestWrapper> remote,
std::vector<SimulcastLayer> init_layers) {
- rtc::scoped_refptr<MediaStreamInterface> stream = local->GetUserMedia(
+ scoped_refptr<MediaStreamInterface> stream = local->GetUserMedia(
/*audio=*/false, AudioOptions(), /*video=*/true,
{.width = 1280, .height = 720});
- rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
+ scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
- transceiver_or_error = local->pc()->AddTransceiver(
- track, CreateTransceiverInit(init_layers));
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> transceiver_or_error =
+ local->pc()->AddTransceiver(track, CreateTransceiverInit(init_layers));
EXPECT_TRUE(transceiver_or_error.ok());
return transceiver_or_error.value();
}
bool HasReceiverVideoCodecCapability(
- rtc::scoped_refptr<PeerConnectionTestWrapper> pc_wrapper,
+ scoped_refptr<PeerConnectionTestWrapper> pc_wrapper,
absl::string_view codec_name) {
std::vector<RtpCodecCapability> codecs =
pc_wrapper->pc_factory()
@@ -270,7 +269,7 @@
}
std::vector<RtpCodecCapability> GetCapabilitiesAndRestrictToCodec(
- rtc::scoped_refptr<PeerConnectionTestWrapper> pc_wrapper,
+ scoped_refptr<PeerConnectionTestWrapper> pc_wrapper,
absl::string_view codec_name) {
std::vector<RtpCodecCapability> codecs =
pc_wrapper->pc_factory()
@@ -292,8 +291,8 @@
}
void ExchangeIceCandidates(
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper,
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper) {
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper,
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper) {
local_pc_wrapper->SignalOnIceCandidateReady.connect(
remote_pc_wrapper.get(), &PeerConnectionTestWrapper::AddIceCandidate);
remote_pc_wrapper->SignalOnIceCandidateReady.connect(
@@ -301,14 +300,13 @@
}
// Negotiate without any tweaks (does not work for simulcast loopback).
- void Negotiate(
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper,
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper) {
+ void Negotiate(scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper,
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper) {
std::unique_ptr<SessionDescriptionInterface> offer =
CreateOffer(local_pc_wrapper);
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> p1 =
+ scoped_refptr<MockSetSessionDescriptionObserver> p1 =
SetLocalDescription(local_pc_wrapper, offer.get());
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> p2 =
+ scoped_refptr<MockSetSessionDescriptionObserver> p2 =
SetRemoteDescription(remote_pc_wrapper, offer.get());
EXPECT_TRUE(Await({p1, p2}));
std::unique_ptr<SessionDescriptionInterface> answer =
@@ -319,17 +317,17 @@
}
void NegotiateWithSimulcastTweaks(
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper,
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper) {
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper,
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper) {
// Create and set offer for `local_pc_wrapper`.
std::unique_ptr<SessionDescriptionInterface> offer =
CreateOffer(local_pc_wrapper);
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> p1 =
+ scoped_refptr<MockSetSessionDescriptionObserver> p1 =
SetLocalDescription(local_pc_wrapper, offer.get());
// Modify the offer before handoff because `remote_pc_wrapper` only supports
// receiving singlecast.
SimulcastDescription simulcast_description = RemoveSimulcast(offer.get());
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> p2 =
+ scoped_refptr<MockSetSessionDescriptionObserver> p2 =
SetRemoteDescription(remote_pc_wrapper, offer.get());
EXPECT_TRUE(Await({p1, p2}));
@@ -354,9 +352,9 @@
EXPECT_TRUE(Await({p1, p2}));
}
- rtc::scoped_refptr<const RTCStatsReport> GetStats(
- rtc::scoped_refptr<PeerConnectionTestWrapper> pc_wrapper) {
- auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>();
+ scoped_refptr<const RTCStatsReport> GetStats(
+ scoped_refptr<PeerConnectionTestWrapper> pc_wrapper) {
+ auto callback = make_ref_counted<MockRTCStatsCollectorCallback>();
pc_wrapper->pc()->GetStats(callback.get());
RTC_CHECK(WaitUntil([&]() { return callback->called(); }, testing::IsTrue())
.ok());
@@ -373,9 +371,8 @@
protected:
std::unique_ptr<SessionDescriptionInterface> CreateOffer(
- rtc::scoped_refptr<PeerConnectionTestWrapper> pc_wrapper) {
- auto observer =
- rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ scoped_refptr<PeerConnectionTestWrapper> pc_wrapper) {
+ auto observer = make_ref_counted<MockCreateSessionDescriptionObserver>();
pc_wrapper->pc()->CreateOffer(observer.get(), {});
EXPECT_THAT(WaitUntil([&] { return observer->called(); }, IsTrue()),
IsRtcOk());
@@ -383,28 +380,27 @@
}
std::unique_ptr<SessionDescriptionInterface> CreateAnswer(
- rtc::scoped_refptr<PeerConnectionTestWrapper> pc_wrapper) {
- auto observer =
- rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ scoped_refptr<PeerConnectionTestWrapper> pc_wrapper) {
+ auto observer = make_ref_counted<MockCreateSessionDescriptionObserver>();
pc_wrapper->pc()->CreateAnswer(observer.get(), {});
EXPECT_THAT(WaitUntil([&] { return observer->called(); }, IsTrue()),
IsRtcOk());
return observer->MoveDescription();
}
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> SetLocalDescription(
- rtc::scoped_refptr<PeerConnectionTestWrapper> pc_wrapper,
+ scoped_refptr<MockSetSessionDescriptionObserver> SetLocalDescription(
+ scoped_refptr<PeerConnectionTestWrapper> pc_wrapper,
SessionDescriptionInterface* sdp) {
- auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockSetSessionDescriptionObserver>();
pc_wrapper->pc()->SetLocalDescription(
observer.get(), CloneSessionDescription(sdp).release());
return observer;
}
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> SetRemoteDescription(
- rtc::scoped_refptr<PeerConnectionTestWrapper> pc_wrapper,
+ scoped_refptr<MockSetSessionDescriptionObserver> SetRemoteDescription(
+ scoped_refptr<PeerConnectionTestWrapper> pc_wrapper,
SessionDescriptionInterface* sdp) {
- auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockSetSessionDescriptionObserver>();
pc_wrapper->pc()->SetRemoteDescription(
observer.get(), CloneSessionDescription(sdp).release());
return observer;
@@ -414,8 +410,8 @@
// the offer it is important to SetLocalDescription() and
// SetRemoteDescription() are kicked off without awaiting in-between. This
// helper is used to await multiple observers.
- bool Await(std::vector<rtc::scoped_refptr<MockSetSessionDescriptionObserver>>
- observers) {
+ bool Await(
+ std::vector<scoped_refptr<MockSetSessionDescriptionObserver>> observers) {
for (auto& observer : observers) {
auto result = WaitUntil([&] { return observer->called(); }, IsTrue());
@@ -432,12 +428,12 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
VP8_SingleEncodingDefaultsToL1T1) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers = CreateLayers({"f"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -456,7 +452,7 @@
ElementsAre(Pair("", ResolutionIs(1280, 720))));
// Verify codec and scalability mode.
- rtc::scoped_refptr<const RTCStatsReport> report = stats_result.value();
+ scoped_refptr<const RTCStatsReport> report = stats_result.value();
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_THAT(outbound_rtps, SizeIs(1u));
@@ -468,12 +464,12 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
VP8_RejectsSvcAndDefaultsToL1T1) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers = CreateLayers({"f"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
// Restricting the local receive codecs will restrict what we offer and
@@ -486,7 +482,7 @@
// Attempt SVC (L3T3_KEY). This is not possible because only VP8 is up for
// negotiation and VP8 does not support it.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L3T3_KEY";
@@ -504,7 +500,7 @@
ASSERT_THAT(GetStatsUntil(local_pc_wrapper, HasOutboundRtpBytesSent(1)),
IsRtcOk());
// When `scalability_mode` is not set, VP8 defaults to L1T1.
- rtc::scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
+ scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_THAT(outbound_rtps, SizeIs(1u));
@@ -519,12 +515,12 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersWithScalabilityModeNotSupportedBySubsequentNegotiation) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers = CreateLayers({"f"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
// Restricting the local receive codecs will restrict what we offer and
@@ -535,7 +531,7 @@
// Attempt SVC (L3T3_KEY). This is still possible because VP9 might be
// available from the remote end.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L3T3_KEY";
@@ -558,7 +554,7 @@
GetStatsUntil(local_pc_wrapper, HasOutboundRtpBytesSent(1));
ASSERT_THAT(error_or_stats, IsRtcOk());
// When `scalability_mode` is not set, VP8 defaults to L1T1.
- rtc::scoped_refptr<const RTCStatsReport> report = error_or_stats.value();
+ scoped_refptr<const RTCStatsReport> report = error_or_stats.value();
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_THAT(outbound_rtps, SizeIs(1u));
@@ -573,12 +569,12 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
VP8_FallbackFromSvcResultsInL1T2) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers = CreateLayers({"f"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
// Verify test assumption that VP8 is first in the list, but don't modify the
@@ -590,7 +586,7 @@
EXPECT_THAT(codecs[0].name, StrCaseEq("VP8"));
// Attempt SVC (L3T3_KEY), which is not possible with VP8, but the sender does
// not yet know which codec we'll use so the parameters will be accepted.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L3T3_KEY";
@@ -619,7 +615,7 @@
IsRtcOk());
// GetStats() confirms "L1T2" is used which is different than the "L1T1"
// default or the "L3T3_KEY" that was attempted.
- rtc::scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
+ scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_THAT(outbound_rtps, SizeIs(1u));
@@ -642,13 +638,13 @@
// (i.e. VP9 is not treated differently than VP8).
TEST_F(PeerConnectionEncodingsIntegrationTest,
VP9_LegacySvcWhenScalabilityModeNotSpecified) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"f", "h", "q"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -676,7 +672,7 @@
// Despite SVC being used on a single RTP stream, GetParameters() returns the
// three encodings that we configured earlier (this is not spec-compliant but
// it is how legacy SVC behaves).
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
std::vector<RtpEncodingParameters> encodings =
sender->GetParameters().encodings;
ASSERT_EQ(encodings.size(), 3u);
@@ -691,19 +687,19 @@
// encoding in GetParameters().
TEST_F(PeerConnectionEncodingsIntegrationTest,
VP9_StandardSvcWithOnlyOneEncoding) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers = CreateLayers({"f"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
GetCapabilitiesAndRestrictToCodec(remote_pc_wrapper, "VP9");
transceiver->SetCodecPreferences(codecs);
// Configure SVC, a.k.a. "L3T3_KEY".
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L3T3_KEY";
@@ -748,20 +744,20 @@
// observable in GetStats().
TEST_F(PeerConnectionEncodingsIntegrationTest,
VP9_StandardSvcWithSingleActiveEncoding) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"f", "h", "q"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
GetCapabilitiesAndRestrictToCodec(remote_pc_wrapper, "VP9");
transceiver->SetCodecPreferences(codecs);
// Configure SVC, a.k.a. "L3T3_KEY".
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(3));
parameters.encodings[0].scalability_mode = "L3T3_KEY";
@@ -800,13 +796,13 @@
// changes from 1 (legacy SVC) to 3 (standard simulcast).
TEST_F(PeerConnectionEncodingsIntegrationTest,
VP9_SwitchFromLegacySvcToStandardSingleActiveEncodingSvc) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"f", "h", "q"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -822,7 +818,7 @@
// Switch to the standard mode. Despite only having a single active stream in
// both cases, this internally reconfigures from 1 stream to 3 streams.
// Test coverage for https://crbug.com/webrtc/15016.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(3));
parameters.encodings[0].active = true;
@@ -857,13 +853,13 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
VP9_SimulcastDeactiveActiveLayer_StandardSvc) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"q", "h", "f"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
constexpr absl::string_view kCodec = "VP9";
@@ -874,7 +870,7 @@
// Switch to the standard mode. Despite only having a single active stream in
// both cases, this internally reconfigures from 1 stream to 3 streams.
// Test coverage for https://crbug.com/webrtc/15016.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(3));
parameters.encodings[0].active = true;
@@ -911,7 +907,7 @@
},
AllOf(SizeIs(3), Each(Gt(0))), {.timeout = kLongTimeoutForRampingUp}),
IsRtcOk());
- rtc::scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
+ scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
ASSERT_TRUE(report);
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
@@ -950,13 +946,13 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
VP9_SimulcastMultiplLayersActive_StandardSvc) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"q", "h", "f"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -966,7 +962,7 @@
// Switch to the standard mode. Despite only having a single active stream in
// both cases, this internally reconfigures from 1 stream to 3 streams.
// Test coverage for https://crbug.com/webrtc/15016.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(3));
parameters.encodings[0].active = true;
@@ -998,7 +994,7 @@
HeightIs(720 / 2), BytesSentIs(Gt(0)))})),
{.timeout = kLongTimeoutForRampingUp});
ASSERT_THAT(error_or_stats, IsRtcOk());
- rtc::scoped_refptr<const RTCStatsReport> report = error_or_stats.value();
+ scoped_refptr<const RTCStatsReport> report = error_or_stats.value();
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
EXPECT_THAT(outbound_rtps, Each(EncoderImplementationIs(
@@ -1016,13 +1012,13 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
VP9_Simulcast_SwitchToLegacySvc) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"f", "h", "q"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -1032,7 +1028,7 @@
// Switch to the standard mode. Despite only having a single active stream in
// both cases, this internally reconfigures from 1 stream to 3 streams.
// Test coverage for https://crbug.com/webrtc/15016.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(3));
parameters.encodings[0].active = false;
@@ -1095,13 +1091,13 @@
}
TEST_F(PeerConnectionEncodingsIntegrationTest, VP9_OneLayerActive_LegacySvc) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"f", "h", "q"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -1109,7 +1105,7 @@
transceiver->SetCodecPreferences(codecs);
// Sending L1T3 with legacy SVC mode means setting 1 layer active.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(3));
parameters.encodings[0].active = true;
@@ -1133,13 +1129,13 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
VP9_AllLayersInactive_LegacySvc) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"f", "h", "q"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -1147,7 +1143,7 @@
transceiver->SetCodecPreferences(codecs);
// Legacy SVC mode and all layers inactive.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(3));
parameters.encodings[0].active = false;
@@ -1161,7 +1157,7 @@
// Ensure no media is flowing (1 second should be enough).
Thread::Current()->SleepMs(1000);
- rtc::scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
+ scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_THAT(outbound_rtps, SizeIs(1u));
@@ -1170,13 +1166,13 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
VP9_AllLayersInactive_StandardSvc) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"f", "h", "q"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -1184,7 +1180,7 @@
transceiver->SetCodecPreferences(codecs);
// Standard mode and all layers inactive.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(3));
parameters.encodings[0].scalability_mode = "L3T3_KEY";
@@ -1200,7 +1196,7 @@
// Ensure no media is flowing (1 second should be enough).
Thread::Current()->SleepMs(1000);
- rtc::scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
+ scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_THAT(outbound_rtps, SizeIs(3u));
@@ -1210,13 +1206,13 @@
}
TEST_F(PeerConnectionEncodingsIntegrationTest, VP9_TargetBitrate_LegacyL1T3) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"f", "h", "q"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -1225,7 +1221,7 @@
// In legacy SVC, disabling the bottom two layers encodings is interpreted as
// disabling the bottom two spatial layers resulting in L1T3.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
parameters.encodings[0].active = false;
parameters.encodings[1].active = false;
@@ -1249,7 +1245,7 @@
// in a short period of time. However to reduce risk of flakiness in bot
// environments, this test only fails if we we exceed the expected target.
Thread::Current()->SleepMs(1000);
- rtc::scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
+ scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_THAT(outbound_rtps, SizeIs(1));
@@ -1260,13 +1256,13 @@
// Test coverage for https://crbug.com/1455039.
TEST_F(PeerConnectionEncodingsIntegrationTest, VP9_TargetBitrate_StandardL1T3) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"f", "h", "q"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -1276,7 +1272,7 @@
// With standard APIs, L1T3 is explicitly specified and the encodings refers
// to the RTP streams, not the spatial layers. The end result should be
// equivalent to the legacy L1T3 case.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
parameters.encodings[0].active = true;
parameters.encodings[0].scale_resolution_down_by = 1.0;
@@ -1302,7 +1298,7 @@
// in a short period of time. However to reduce risk of flakiness in bot
// environments, this test only fails if we we exceed the expected target.
Thread::Current()->SleepMs(1000);
- rtc::scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
+ scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_THAT(outbound_rtps, SizeIs(3));
@@ -1314,13 +1310,13 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
SimulcastProducesUniqueSsrcAndRtxSsrcs) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"f", "h", "q"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -1337,7 +1333,7 @@
{.timeout = kLongTimeoutForRampingUp});
ASSERT_THAT(stats, IsRtcOk());
// Verify SSRCs and RTX SSRCs.
- rtc::scoped_refptr<const RTCStatsReport> report = stats.MoveValue();
+ scoped_refptr<const RTCStatsReport> report = stats.MoveValue();
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_THAT(outbound_rtps, SizeIs(3u));
@@ -1356,11 +1352,11 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
EncodingParameterCodecIsEmptyWhenCreatedAudio) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(webrtc::MediaType::AUDIO);
- rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
+ scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
EXPECT_FALSE(parameters.encodings[0].codec.has_value());
@@ -1368,11 +1364,11 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
EncodingParameterCodecIsEmptyWhenCreatedVideo) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(webrtc::MediaType::VIDEO);
- rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
+ scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue();
RtpParameters parameters = video_transceiver->sender()->GetParameters();
EXPECT_FALSE(parameters.encodings[0].codec.has_value());
@@ -1380,14 +1376,13 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
EncodingParameterCodecIsSetByAddTransceiverAudio) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
- rtc::scoped_refptr<MediaStreamInterface> stream =
- local_pc_wrapper->GetUserMedia(
- /*audio=*/true, {}, /*video=*/false, {});
- rtc::scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0];
+ scoped_refptr<MediaStreamInterface> stream = local_pc_wrapper->GetUserMedia(
+ /*audio=*/true, {}, /*video=*/false, {});
+ scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0];
std::optional<RtpCodecCapability> pcmu =
local_pc_wrapper->FindFirstSendCodecWithName(webrtc::MediaType::AUDIO,
@@ -1402,7 +1397,7 @@
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(track, init);
- rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
+ scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
EXPECT_EQ(*parameters.encodings[0].codec, *pcmu);
@@ -1411,7 +1406,7 @@
ASSERT_TRUE(local_pc_wrapper->WaitForConnection());
ASSERT_TRUE(remote_pc_wrapper->WaitForConnection());
- rtc::scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
+ scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_EQ(outbound_rtps.size(), 1u);
@@ -1421,14 +1416,13 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
EncodingParameterCodecIsSetByAddTransceiverVideo) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
- rtc::scoped_refptr<MediaStreamInterface> stream =
- local_pc_wrapper->GetUserMedia(
- /*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720});
- rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
+ scoped_refptr<MediaStreamInterface> stream = local_pc_wrapper->GetUserMedia(
+ /*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720});
+ scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
std::optional<RtpCodecCapability> vp9 =
local_pc_wrapper->FindFirstSendCodecWithName(webrtc::MediaType::VIDEO,
@@ -1444,7 +1438,7 @@
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(track, init);
- rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
+ scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
EXPECT_EQ(*parameters.encodings[0].codec, *vp9);
@@ -1457,7 +1451,7 @@
GetStatsUntil(local_pc_wrapper,
OutboundRtpStatsAre(Contains(ScalabilityModeIs("L3T3"))));
ASSERT_THAT(error_or_stats, IsRtcOk());
- rtc::scoped_refptr<const RTCStatsReport> report = error_or_stats.MoveValue();
+ scoped_refptr<const RTCStatsReport> report = error_or_stats.MoveValue();
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_EQ(outbound_rtps.size(), 1u);
@@ -1468,21 +1462,20 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
EncodingParameterCodecIsSetBySetParametersBeforeNegotiationAudio) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
- rtc::scoped_refptr<MediaStreamInterface> stream =
- local_pc_wrapper->GetUserMedia(
- /*audio=*/true, {}, /*video=*/false, {});
- rtc::scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0];
+ scoped_refptr<MediaStreamInterface> stream = local_pc_wrapper->GetUserMedia(
+ /*audio=*/true, {}, /*video=*/false, {});
+ scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0];
std::optional<RtpCodecCapability> pcmu =
local_pc_wrapper->FindFirstSendCodecWithName(webrtc::MediaType::AUDIO,
"pcmu");
auto transceiver_or_error = local_pc_wrapper->pc()->AddTransceiver(track);
- rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
+ scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = pcmu;
@@ -1495,7 +1488,7 @@
local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection();
- rtc::scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
+ scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_EQ(outbound_rtps.size(), 1u);
@@ -1505,28 +1498,27 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
EncodingParameterCodecIsSetBySetParametersAfterNegotiationAudio) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
- rtc::scoped_refptr<MediaStreamInterface> stream =
- local_pc_wrapper->GetUserMedia(
- /*audio=*/true, {}, /*video=*/false, {});
- rtc::scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0];
+ scoped_refptr<MediaStreamInterface> stream = local_pc_wrapper->GetUserMedia(
+ /*audio=*/true, {}, /*video=*/false, {});
+ scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0];
std::optional<RtpCodecCapability> pcmu =
local_pc_wrapper->FindFirstSendCodecWithName(webrtc::MediaType::AUDIO,
"pcmu");
auto transceiver_or_error = local_pc_wrapper->pc()->AddTransceiver(track);
- rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
+ scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
NegotiateWithSimulcastTweaks(local_pc_wrapper, remote_pc_wrapper);
local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection();
- rtc::scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
+ scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_EQ(outbound_rtps.size(), 1u);
@@ -1554,21 +1546,20 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
EncodingParameterCodecIsSetBySetParametersBeforeNegotiationVideo) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
- rtc::scoped_refptr<MediaStreamInterface> stream =
- local_pc_wrapper->GetUserMedia(
- /*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720});
- rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
+ scoped_refptr<MediaStreamInterface> stream = local_pc_wrapper->GetUserMedia(
+ /*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720});
+ scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
std::optional<RtpCodecCapability> vp9 =
local_pc_wrapper->FindFirstSendCodecWithName(webrtc::MediaType::VIDEO,
"vp9");
auto transceiver_or_error = local_pc_wrapper->pc()->AddTransceiver(track);
- rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
+ scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue();
RtpParameters parameters = video_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = vp9;
@@ -1587,7 +1578,7 @@
local_pc_wrapper, OutboundRtpStatsAre(Contains(AllOf(
ScalabilityModeIs("L3T3"), CodecIs(Ne(""))))));
ASSERT_THAT(error_or_stats, IsRtcOk());
- rtc::scoped_refptr<const RTCStatsReport> report = error_or_stats.MoveValue();
+ scoped_refptr<const RTCStatsReport> report = error_or_stats.MoveValue();
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_EQ(outbound_rtps.size(), 1u);
@@ -1598,28 +1589,27 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
EncodingParameterCodecIsSetBySetParametersAfterNegotiationVideo) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
- rtc::scoped_refptr<MediaStreamInterface> stream =
- local_pc_wrapper->GetUserMedia(
- /*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720});
- rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
+ scoped_refptr<MediaStreamInterface> stream = local_pc_wrapper->GetUserMedia(
+ /*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720});
+ scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
std::optional<RtpCodecCapability> vp9 =
local_pc_wrapper->FindFirstSendCodecWithName(webrtc::MediaType::VIDEO,
"vp9");
auto transceiver_or_error = local_pc_wrapper->pc()->AddTransceiver(track);
- rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
+ scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue();
NegotiateWithSimulcastTweaks(local_pc_wrapper, remote_pc_wrapper);
local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection();
- rtc::scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
+ scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_EQ(outbound_rtps.size(), 1u);
@@ -1651,7 +1641,7 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
AddTransceiverRejectsUnknownCodecParameterAudio) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
RtpCodec dummy_codec;
dummy_codec.kind = webrtc::MediaType::AUDIO;
@@ -1674,7 +1664,7 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
AddTransceiverRejectsUnknownCodecParameterVideo) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
RtpCodec dummy_codec;
dummy_codec.kind = webrtc::MediaType::VIDEO;
@@ -1696,7 +1686,7 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsUnknownCodecParameterAudio) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
RtpCodec dummy_codec;
dummy_codec.kind = webrtc::MediaType::AUDIO;
@@ -1707,7 +1697,7 @@
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(webrtc::MediaType::AUDIO);
ASSERT_TRUE(transceiver_or_error.ok());
- rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
+ scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
@@ -1718,7 +1708,7 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsUnknownCodecParameterVideo) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
RtpCodec dummy_codec;
dummy_codec.kind = webrtc::MediaType::VIDEO;
@@ -1728,7 +1718,7 @@
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(webrtc::MediaType::VIDEO);
ASSERT_TRUE(transceiver_or_error.ok());
- rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
+ scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue();
RtpParameters parameters = video_transceiver->sender()->GetParameters();
@@ -1739,8 +1729,8 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsNonNegotiatedCodecParameterAudio) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::optional<RtpCodecCapability> opus =
@@ -1762,7 +1752,7 @@
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(webrtc::MediaType::AUDIO);
ASSERT_TRUE(transceiver_or_error.ok());
- rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
+ scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
ASSERT_TRUE(audio_transceiver->SetCodecPreferences(not_opus_codecs).ok());
@@ -1778,8 +1768,8 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsNonRemotelyNegotiatedCodecParameterAudio) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::optional<RtpCodecCapability> opus =
@@ -1801,23 +1791,23 @@
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(webrtc::MediaType::AUDIO);
ASSERT_TRUE(transceiver_or_error.ok());
- rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
+ scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
// Negotiation, create offer and apply it
std::unique_ptr<SessionDescriptionInterface> offer =
CreateOffer(local_pc_wrapper);
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> p1 =
+ scoped_refptr<MockSetSessionDescriptionObserver> p1 =
SetLocalDescription(local_pc_wrapper, offer.get());
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> p2 =
+ scoped_refptr<MockSetSessionDescriptionObserver> p2 =
SetRemoteDescription(remote_pc_wrapper, offer.get());
EXPECT_TRUE(Await({p1, p2}));
// Update the remote transceiver to reject Opus
- std::vector<rtc::scoped_refptr<RtpTransceiverInterface>> remote_transceivers =
+ std::vector<scoped_refptr<RtpTransceiverInterface>> remote_transceivers =
remote_pc_wrapper->pc()->GetTransceivers();
ASSERT_TRUE(!remote_transceivers.empty());
- rtc::scoped_refptr<RtpTransceiverInterface> remote_audio_transceiver =
+ scoped_refptr<RtpTransceiverInterface> remote_audio_transceiver =
remote_transceivers[0];
ASSERT_TRUE(
remote_audio_transceiver->SetCodecPreferences(not_opus_codecs).ok());
@@ -1845,14 +1835,14 @@
// still work.
TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersAcceptsMungedCodecFromGetParameters) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(webrtc::MediaType::VIDEO);
ASSERT_TRUE(transceiver_or_error.ok());
- rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
+ scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue();
std::unique_ptr<SessionDescriptionInterface> offer =
@@ -1867,9 +1857,9 @@
vp8_codec->params.emplace("non-standard-param", "true");
mcd->set_codecs(codecs);
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> p1 =
+ scoped_refptr<MockSetSessionDescriptionObserver> p1 =
SetLocalDescription(local_pc_wrapper, offer.get());
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> p2 =
+ scoped_refptr<MockSetSessionDescriptionObserver> p2 =
SetRemoteDescription(remote_pc_wrapper, offer.get());
EXPECT_TRUE(Await({p1, p2}));
@@ -1906,8 +1896,8 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsNonNegotiatedCodecParameterVideo) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::optional<RtpCodecCapability> vp8 =
@@ -1929,7 +1919,7 @@
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(webrtc::MediaType::VIDEO);
ASSERT_TRUE(transceiver_or_error.ok());
- rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
+ scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue();
ASSERT_TRUE(video_transceiver->SetCodecPreferences(not_vp8_codecs).ok());
@@ -1945,8 +1935,8 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsNonRemotelyNegotiatedCodecParameterVideo) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::optional<RtpCodecCapability> vp8 =
@@ -1968,23 +1958,23 @@
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(webrtc::MediaType::VIDEO);
ASSERT_TRUE(transceiver_or_error.ok());
- rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
+ scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue();
// Negotiation, create offer and apply it
std::unique_ptr<SessionDescriptionInterface> offer =
CreateOffer(local_pc_wrapper);
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> p1 =
+ scoped_refptr<MockSetSessionDescriptionObserver> p1 =
SetLocalDescription(local_pc_wrapper, offer.get());
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> p2 =
+ scoped_refptr<MockSetSessionDescriptionObserver> p2 =
SetRemoteDescription(remote_pc_wrapper, offer.get());
EXPECT_TRUE(Await({p1, p2}));
// Update the remote transceiver to reject VP8
- std::vector<rtc::scoped_refptr<RtpTransceiverInterface>> remote_transceivers =
+ std::vector<scoped_refptr<RtpTransceiverInterface>> remote_transceivers =
remote_pc_wrapper->pc()->GetTransceivers();
ASSERT_TRUE(!remote_transceivers.empty());
- rtc::scoped_refptr<RtpTransceiverInterface> remote_video_transceiver =
+ scoped_refptr<RtpTransceiverInterface> remote_video_transceiver =
remote_transceivers[0];
ASSERT_TRUE(
remote_video_transceiver->SetCodecPreferences(not_vp8_codecs).ok());
@@ -2007,8 +1997,8 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
EncodingParametersCodecRemovedAfterNegotiationAudio) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::optional<RtpCodecCapability> opus =
@@ -2036,7 +2026,7 @@
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(webrtc::MediaType::AUDIO, init);
ASSERT_TRUE(transceiver_or_error.ok());
- rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
+ scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
NegotiateWithSimulcastTweaks(local_pc_wrapper, remote_pc_wrapper);
@@ -2055,8 +2045,8 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
EncodingParametersRedEnabledBeforeNegotiationAudio) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<RtpCodecCapability> send_codecs =
@@ -2083,7 +2073,7 @@
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(webrtc::MediaType::AUDIO, init);
ASSERT_TRUE(transceiver_or_error.ok());
- rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
+ scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
// Preferring RED over Opus should enable RED with Opus encoding.
@@ -2113,7 +2103,7 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsScalabilityModeForSelectedCodec) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
std::optional<RtpCodecCapability> vp8 =
local_pc_wrapper->FindFirstSendCodecWithName(webrtc::MediaType::VIDEO,
@@ -2130,7 +2120,7 @@
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(webrtc::MediaType::VIDEO, init);
ASSERT_TRUE(transceiver_or_error.ok());
- rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
+ scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue();
RtpParameters parameters = video_transceiver->sender()->GetParameters();
@@ -2141,8 +2131,8 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
EncodingParametersCodecRemovedByNegotiationVideo) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::optional<RtpCodecCapability> vp8 =
@@ -2175,7 +2165,7 @@
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(webrtc::MediaType::VIDEO, init);
ASSERT_TRUE(transceiver_or_error.ok());
- rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
+ scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue();
NegotiateWithSimulcastTweaks(local_pc_wrapper, remote_pc_wrapper);
@@ -2199,8 +2189,8 @@
AddTransceiverRejectsMixedCodecSimulcast) {
// Mixed Codec Simulcast is not yet supported, so we ensure that we reject
// such parameters.
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::optional<RtpCodecCapability> vp8 =
@@ -2268,7 +2258,7 @@
}
TEST_F(PeerConnectionEncodingsIntegrationTest, ScaleToParameterChecking) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> pc_wrapper = CreatePc();
// AddTransceiver: If `scale_resolution_down_to` is specified on any encoding
// it must be specified on all encodings.
@@ -2353,13 +2343,12 @@
TEST_F(PeerConnectionEncodingsIntegrationTest,
ScaleResolutionDownByIsIgnoredWhenScaleToIsSpecified) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
- rtc::scoped_refptr<MediaStreamInterface> stream =
- local_pc_wrapper->GetUserMedia(
- /*audio=*/false, {}, /*video=*/true, {.width = 640, .height = 360});
- rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
+ scoped_refptr<MediaStreamInterface> stream = local_pc_wrapper->GetUserMedia(
+ /*audio=*/false, {}, /*video=*/true, {.width = 640, .height = 360});
+ scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
// Configure contradicting scaling factors (180p vs 360p).
RtpTransceiverInit init;
@@ -2399,7 +2388,7 @@
// TODO(https://crbug.com/webrtc/15011): Increase availability of AV1 or make
// it possible to check support at compile-time.
bool SkipTestDueToAv1Missing(
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper) {
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper) {
if (codec_name_ == "AV1" &&
!HasReceiverVideoCodecCapability(local_pc_wrapper, "AV1")) {
RTC_LOG(LS_WARNING) << "\n***\nAV1 is not available, skipping test.\n***";
@@ -2414,16 +2403,16 @@
};
TEST_P(PeerConnectionEncodingsIntegrationParameterizedTest, AllLayersInactive) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
if (SkipTestDueToAv1Missing(local_pc_wrapper)) {
return;
}
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"f", "h", "q"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -2431,7 +2420,7 @@
transceiver->SetCodecPreferences(codecs);
// Standard mode and all layers inactive.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(3));
parameters.encodings[0].scalability_mode = "L1T3";
@@ -2447,7 +2436,7 @@
// Ensure no media is flowing (1 second should be enough).
Thread::Current()->SleepMs(1000);
- rtc::scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
+ scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_THAT(outbound_rtps, SizeIs(3u));
@@ -2458,23 +2447,23 @@
// Configure 4:2:1 using `scale_resolution_down_by`.
TEST_P(PeerConnectionEncodingsIntegrationParameterizedTest, Simulcast) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
if (SkipTestDueToAv1Missing(local_pc_wrapper)) {
return;
}
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"q", "h", "f"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
GetCapabilitiesAndRestrictToCodec(remote_pc_wrapper, codec_name_);
transceiver->SetCodecPreferences(codecs);
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(3));
parameters.encodings[0].scalability_mode = "L1T3";
@@ -2506,7 +2495,7 @@
{.timeout = kLongTimeoutForRampingUp});
ASSERT_THAT(error_or_report, IsRtcOk());
// Verify codec and scalability mode.
- rtc::scoped_refptr<const RTCStatsReport> report = error_or_report.value();
+ scoped_refptr<const RTCStatsReport> report = error_or_report.value();
auto outbound_rtp_by_rid = GetOutboundRtpStreamStatsByRid(report);
EXPECT_THAT(outbound_rtp_by_rid,
UnorderedElementsAre(Pair("q", ResolutionIs(320, 180)),
@@ -2529,23 +2518,23 @@
// Configure 4:2:1 using `scale_resolution_down_to`.
TEST_P(PeerConnectionEncodingsIntegrationParameterizedTest,
SimulcastWithScaleTo) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
if (SkipTestDueToAv1Missing(local_pc_wrapper)) {
return;
}
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"q", "h", "f"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
GetCapabilitiesAndRestrictToCodec(remote_pc_wrapper, codec_name_);
transceiver->SetCodecPreferences(codecs);
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(3));
parameters.encodings[0].scalability_mode = "L1T3";
@@ -2580,7 +2569,7 @@
{.timeout = kLongTimeoutForRampingUp});
ASSERT_THAT(error_or_report, IsRtcOk());
// Verify codec and scalability mode.
- rtc::scoped_refptr<const RTCStatsReport> report = error_or_report.value();
+ scoped_refptr<const RTCStatsReport> report = error_or_report.value();
auto outbound_rtp_by_rid = GetOutboundRtpStreamStatsByRid(report);
EXPECT_THAT(outbound_rtp_by_rid,
UnorderedElementsAre(Pair("q", ResolutionIs(320, 180)),
@@ -2605,22 +2594,22 @@
// the `scale_resolution_down_by` API.
TEST_P(PeerConnectionEncodingsIntegrationParameterizedTest,
SimulcastScaleDownByNoLongerPowerOfTwo) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
if (SkipTestDueToAv1Missing(local_pc_wrapper)) {
return;
}
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"q", "h", "f"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
GetCapabilitiesAndRestrictToCodec(remote_pc_wrapper, codec_name_);
transceiver->SetCodecPreferences(codecs);
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
// Configure {180p, 360p, 720p}.
RtpParameters parameters = sender->GetParameters();
@@ -2692,22 +2681,22 @@
// the `scale_resolution_down_to` API.
TEST_P(PeerConnectionEncodingsIntegrationParameterizedTest,
SimulcastScaleToNoLongerPowerOfTwo) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
if (SkipTestDueToAv1Missing(local_pc_wrapper)) {
return;
}
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"q", "h", "f"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
GetCapabilitiesAndRestrictToCodec(remote_pc_wrapper, codec_name_);
transceiver->SetCodecPreferences(codecs);
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
// Configure {180p, 360p, 720p}.
RtpParameters parameters = sender->GetParameters();
@@ -2789,11 +2778,11 @@
// have to repeat here.)
TEST_P(PeerConnectionEncodingsIntegrationParameterizedTest,
LowResolutionSimulcastWithScaleTo) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
if (SkipTestDueToAv1Missing(local_pc_wrapper)) {
return;
}
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
@@ -2812,14 +2801,13 @@
encoding.rid = "f";
encoding.scale_resolution_down_to = {.width = 160, .height = 80};
init.send_encodings.push_back(encoding);
- rtc::scoped_refptr<MediaStreamInterface> stream =
- local_pc_wrapper->GetUserMedia(
- /*audio=*/false, {}, /*video=*/true, {.width = 160, .height = 80});
- rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
+ scoped_refptr<MediaStreamInterface> stream = local_pc_wrapper->GetUserMedia(
+ /*audio=*/false, {}, /*video=*/true, {.width = 160, .height = 80});
+ scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
auto transceiver_or_error =
local_pc_wrapper->pc()->AddTransceiver(track, init);
ASSERT_TRUE(transceiver_or_error.ok());
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
transceiver_or_error.value();
std::vector<RtpCodecCapability> codecs =
@@ -2845,23 +2833,23 @@
TEST_P(PeerConnectionEncodingsIntegrationParameterizedTest,
SimulcastEncodingStopWhenRtpEncodingChangeToInactive) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
if (SkipTestDueToAv1Missing(local_pc_wrapper)) {
return;
}
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"q", "h", "f"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
GetCapabilitiesAndRestrictToCodec(local_pc_wrapper, codec_name_);
transceiver->SetCodecPreferences(codecs);
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(3));
ASSERT_EQ(parameters.encodings[0].rid, "q");
@@ -2916,17 +2904,17 @@
TEST_P(PeerConnectionEncodingsIntegrationParameterizedTest,
ScaleToDownscaleAndThenUpscale) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
if (SkipTestDueToAv1Missing(local_pc_wrapper)) {
return;
}
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers = CreateLayers({"f"}, /*active=*/true);
// This transceiver receives a 1280x720 source.
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -2938,7 +2926,7 @@
remote_pc_wrapper->WaitForConnection();
// Request 640x360, which is the same as scaling down by 2.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(1));
parameters.encodings[0].scalability_mode = "L1T3";
@@ -2976,17 +2964,17 @@
TEST_P(PeerConnectionEncodingsIntegrationParameterizedTest,
ScaleToIsOrientationAgnostic) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
if (SkipTestDueToAv1Missing(local_pc_wrapper)) {
return;
}
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers = CreateLayers({"f"}, /*active=*/true);
// This transceiver receives a 1280x720 source.
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -2999,7 +2987,7 @@
// 360x640 is the same as 640x360 due to orientation agnosticism.
// The orientation is determined by the frame (1280x720): landscape.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(1));
parameters.encodings[0].scale_resolution_down_to = {.width = 360,
@@ -3014,17 +3002,17 @@
TEST_P(PeerConnectionEncodingsIntegrationParameterizedTest,
ScaleToMaintainsAspectRatio) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
if (SkipTestDueToAv1Missing(local_pc_wrapper)) {
return;
}
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers = CreateLayers({"f"}, /*active=*/true);
// This transceiver receives a 1280x720 source.
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> codecs =
@@ -3037,7 +3025,7 @@
// Restrict height more than width, the scaling factor needed on height should
// also be applied on the width in order to maintain the frame aspect ratio.
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
RtpParameters parameters = sender->GetParameters();
ASSERT_THAT(parameters.encodings, SizeIs(1));
parameters.encodings[0].scale_resolution_down_to = {.width = 1280,
@@ -3144,13 +3132,13 @@
#ifdef RTC_ENABLE_H265
TEST_F(PeerConnectionEncodingsFakeCodecsIntegrationTest, H265Singlecast) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper =
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper =
CreatePcWithFakeH265();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper =
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper =
CreatePcWithFakeH265();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
local_pc_wrapper->pc()
->AddTransceiver(webrtc::MediaType::VIDEO)
.MoveValue();
@@ -3163,7 +3151,7 @@
remote_pc_wrapper->WaitForConnection();
// Verify codec.
- rtc::scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
+ scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_THAT(outbound_rtps, SizeIs(1u));
@@ -3172,16 +3160,16 @@
}
TEST_F(PeerConnectionEncodingsFakeCodecsIntegrationTest, H265Simulcast) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper =
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper =
CreatePcWithFakeH265();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper =
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper =
CreatePcWithFakeH265();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers =
CreateLayers({"q", "h", "f"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> preferred_codecs =
@@ -3200,7 +3188,7 @@
IsRtcOk());
// Verify codec.
- rtc::scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
+ scoped_refptr<const RTCStatsReport> report = GetStats(local_pc_wrapper);
std::vector<const RTCOutboundRtpStreamStats*> outbound_rtps =
report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_THAT(outbound_rtps, SizeIs(3u));
@@ -3214,21 +3202,21 @@
TEST_F(PeerConnectionEncodingsFakeCodecsIntegrationTest,
H265SetParametersIgnoresLevelId) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper =
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper =
CreatePcWithFakeH265();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper =
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper =
CreatePcWithFakeH265();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<SimulcastLayer> layers = CreateLayers({"f"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
std::vector<RtpCodecCapability> preferred_codecs =
GetCapabilitiesAndRestrictToCodec(local_pc_wrapper, "H265");
transceiver->SetCodecPreferences(preferred_codecs);
- rtc::scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
+ scoped_refptr<RtpSenderInterface> sender = transceiver->sender();
NegotiateWithSimulcastTweaks(local_pc_wrapper, remote_pc_wrapper);
local_pc_wrapper->WaitForConnection();
@@ -3276,13 +3264,13 @@
TEST_F(PeerConnectionEncodingsFakeCodecsIntegrationTest,
H264UnidirectionalNegotiation) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper =
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper =
CreatePcWithUnidirectionalH264();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper =
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper =
CreatePcWithUnidirectionalH264();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
local_pc_wrapper->pc()
->AddTransceiver(webrtc::MediaType::VIDEO)
.MoveValue();
@@ -3416,13 +3404,13 @@
// Regression test for https://issues.chromium.org/issues/399667359
TEST_F(PeerConnectionEncodingsIntegrationTest,
SimulcastNotSupportedGetParametersDoesNotCrash) {
- rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
- rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
+ scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
- std::vector<cricket::SimulcastLayer> layers =
+ std::vector<SimulcastLayer> layers =
CreateLayers({"f", "q"}, /*active=*/true);
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver =
+ scoped_refptr<RtpTransceiverInterface> transceiver =
AddTransceiverWithSimulcastLayers(local_pc_wrapper, remote_pc_wrapper,
layers);
// Negotiate - receiver will reject simulcast, so the 2nd layer will be
diff --git a/pc/peer_connection_end_to_end_unittest.cc b/pc/peer_connection_end_to_end_unittest.cc
index c31625b..2fcf4dc 100644
--- a/pc/peer_connection_end_to_end_unittest.cc
+++ b/pc/peer_connection_end_to_end_unittest.cc
@@ -80,16 +80,17 @@
class PeerConnectionEndToEndBaseTest : public sigslot::has_slots<>,
public ::testing::Test {
public:
- typedef std::vector<rtc::scoped_refptr<DataChannelInterface>> DataChannelList;
+ typedef std::vector<webrtc::scoped_refptr<DataChannelInterface>>
+ DataChannelList;
explicit PeerConnectionEndToEndBaseTest(SdpSemantics sdp_semantics)
: network_thread_(std::make_unique<webrtc::Thread>(&pss_)),
worker_thread_(webrtc::Thread::Create()) {
RTC_CHECK(network_thread_->Start());
RTC_CHECK(worker_thread_->Start());
- caller_ = rtc::make_ref_counted<PeerConnectionTestWrapper>(
+ caller_ = webrtc::make_ref_counted<PeerConnectionTestWrapper>(
"caller", &pss_, network_thread_.get(), worker_thread_.get());
- callee_ = rtc::make_ref_counted<PeerConnectionTestWrapper>(
+ callee_ = webrtc::make_ref_counted<PeerConnectionTestWrapper>(
"callee", &pss_, network_thread_.get(), worker_thread_.get());
webrtc::PeerConnectionInterface::IceServer ice_server;
ice_server.uri = "stun:stun.l.google.com:19302";
@@ -102,10 +103,11 @@
}
void CreatePcs(
- rtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory1,
- rtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory1,
- rtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory2,
- rtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory2) {
+ webrtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory1,
+ webrtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory1,
+ webrtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory2,
+ webrtc::scoped_refptr<webrtc::AudioDecoderFactory>
+ audio_decoder_factory2) {
EXPECT_TRUE(caller_->CreatePc(config_, audio_encoder_factory1,
audio_decoder_factory1));
EXPECT_TRUE(callee_->CreatePc(config_, audio_encoder_factory2,
@@ -119,8 +121,9 @@
}
void CreatePcs(
- rtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory,
- rtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory) {
+ webrtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory,
+ webrtc::scoped_refptr<webrtc::AudioDecoderFactory>
+ audio_decoder_factory) {
CreatePcs(audio_encoder_factory, audio_decoder_factory,
audio_encoder_factory, audio_decoder_factory);
}
@@ -154,12 +157,12 @@
void OnCallerAddedDataChanel(DataChannelInterface* dc) {
caller_signaled_data_channels_.push_back(
- rtc::scoped_refptr<DataChannelInterface>(dc));
+ webrtc::scoped_refptr<DataChannelInterface>(dc));
}
void OnCalleeAddedDataChannel(DataChannelInterface* dc) {
callee_signaled_data_channels_.push_back(
- rtc::scoped_refptr<DataChannelInterface>(dc));
+ webrtc::scoped_refptr<DataChannelInterface>(dc));
}
// Tests that `dc1` and `dc2` can send to and receive from each other.
@@ -188,7 +191,7 @@
EXPECT_THAT(
webrtc::WaitUntil(
[&] {
- return rtc::CopyOnWriteBuffer(dc2_observer->last_message());
+ return webrtc::CopyOnWriteBuffer(dc2_observer->last_message());
},
::testing::Eq(buffer.data),
{.timeout = webrtc::TimeDelta::Millis(kMaxWait)}),
@@ -198,7 +201,7 @@
EXPECT_THAT(
webrtc::WaitUntil(
[&] {
- return rtc::CopyOnWriteBuffer(dc1_observer->last_message());
+ return webrtc::CopyOnWriteBuffer(dc1_observer->last_message());
},
::testing::Eq(buffer.data),
{.timeout = webrtc::TimeDelta::Millis(kMaxWait)}),
@@ -253,8 +256,8 @@
webrtc::PhysicalSocketServer pss_;
std::unique_ptr<webrtc::Thread> network_thread_;
std::unique_ptr<webrtc::Thread> worker_thread_;
- rtc::scoped_refptr<PeerConnectionTestWrapper> caller_;
- rtc::scoped_refptr<PeerConnectionTestWrapper> callee_;
+ webrtc::scoped_refptr<PeerConnectionTestWrapper> caller_;
+ webrtc::scoped_refptr<PeerConnectionTestWrapper> callee_;
DataChannelList caller_signaled_data_channels_;
DataChannelList callee_signaled_data_channels_;
webrtc::PeerConnectionInterface::RTCConfiguration config_;
@@ -312,11 +315,11 @@
return std::move(mock_decoder);
}
-rtc::scoped_refptr<webrtc::AudioDecoderFactory>
+webrtc::scoped_refptr<webrtc::AudioDecoderFactory>
CreateForwardingMockDecoderFactory(
webrtc::AudioDecoderFactory* real_decoder_factory) {
- rtc::scoped_refptr<webrtc::MockAudioDecoderFactory> mock_decoder_factory =
- rtc::make_ref_counted<StrictMock<webrtc::MockAudioDecoderFactory>>();
+ webrtc::scoped_refptr<webrtc::MockAudioDecoderFactory> mock_decoder_factory =
+ webrtc::make_ref_counted<StrictMock<webrtc::MockAudioDecoderFactory>>();
EXPECT_CALL(*mock_decoder_factory, GetSupportedDecoders())
.Times(AtLeast(1))
.WillRepeatedly(Invoke([real_decoder_factory] {
@@ -414,7 +417,7 @@
} // namespace
TEST_P(PeerConnectionEndToEndTest, Call) {
- rtc::scoped_refptr<webrtc::AudioDecoderFactory> real_decoder_factory =
+ webrtc::scoped_refptr<webrtc::AudioDecoderFactory> real_decoder_factory =
webrtc::CreateOpusAudioDecoderFactory();
CreatePcs(webrtc::CreateOpusAudioEncoderFactory(),
CreateForwardingMockDecoderFactory(real_decoder_factory.get()));
@@ -438,7 +441,7 @@
class IdLoggingAudioEncoderFactory : public webrtc::AudioEncoderFactory {
public:
IdLoggingAudioEncoderFactory(
- rtc::scoped_refptr<AudioEncoderFactory> real_factory,
+ webrtc::scoped_refptr<AudioEncoderFactory> real_factory,
std::vector<webrtc::AudioCodecPairId>* const codec_ids)
: fact_(real_factory), codec_ids_(codec_ids) {}
std::vector<webrtc::AudioCodecSpec> GetSupportedEncoders() override {
@@ -458,14 +461,14 @@
}
private:
- const rtc::scoped_refptr<webrtc::AudioEncoderFactory> fact_;
+ const webrtc::scoped_refptr<webrtc::AudioEncoderFactory> fact_;
std::vector<webrtc::AudioCodecPairId>* const codec_ids_;
};
class IdLoggingAudioDecoderFactory : public webrtc::AudioDecoderFactory {
public:
IdLoggingAudioDecoderFactory(
- rtc::scoped_refptr<AudioDecoderFactory> real_factory,
+ webrtc::scoped_refptr<AudioDecoderFactory> real_factory,
std::vector<webrtc::AudioCodecPairId>* const codec_ids)
: fact_(real_factory), codec_ids_(codec_ids) {}
std::vector<webrtc::AudioCodecSpec> GetSupportedDecoders() override {
@@ -484,25 +487,25 @@
}
private:
- const rtc::scoped_refptr<webrtc::AudioDecoderFactory> fact_;
+ const webrtc::scoped_refptr<webrtc::AudioDecoderFactory> fact_;
std::vector<webrtc::AudioCodecPairId>* const codec_ids_;
};
std::vector<webrtc::AudioCodecPairId> encoder_id1, encoder_id2, decoder_id1,
decoder_id2;
- CreatePcs(rtc::make_ref_counted<IdLoggingAudioEncoderFactory>(
+ CreatePcs(webrtc::make_ref_counted<IdLoggingAudioEncoderFactory>(
webrtc::CreateAudioEncoderFactory<
AudioEncoderUnicornSparklesRainbow>(),
&encoder_id1),
- rtc::make_ref_counted<IdLoggingAudioDecoderFactory>(
+ webrtc::make_ref_counted<IdLoggingAudioDecoderFactory>(
webrtc::CreateAudioDecoderFactory<
AudioDecoderUnicornSparklesRainbow>(),
&decoder_id1),
- rtc::make_ref_counted<IdLoggingAudioEncoderFactory>(
+ webrtc::make_ref_counted<IdLoggingAudioEncoderFactory>(
webrtc::CreateAudioEncoderFactory<
AudioEncoderUnicornSparklesRainbow>(),
&encoder_id2),
- rtc::make_ref_counted<IdLoggingAudioDecoderFactory>(
+ webrtc::make_ref_counted<IdLoggingAudioDecoderFactory>(
webrtc::CreateAudioDecoderFactory<
AudioDecoderUnicornSparklesRainbow>(),
&decoder_id2));
@@ -529,9 +532,9 @@
webrtc::MockAudioDecoderFactory::CreateEmptyFactory());
webrtc::DataChannelInit init;
- rtc::scoped_refptr<DataChannelInterface> caller_dc(
+ webrtc::scoped_refptr<DataChannelInterface> caller_dc(
caller_->CreateDataChannel("data", init));
- rtc::scoped_refptr<DataChannelInterface> callee_dc(
+ webrtc::scoped_refptr<DataChannelInterface> callee_dc(
callee_->CreateDataChannel("data", init));
Negotiate();
@@ -558,7 +561,7 @@
webrtc::DataChannelInit init;
// This DataChannel is for creating the data content in the negotiation.
- rtc::scoped_refptr<DataChannelInterface> dummy(
+ webrtc::scoped_refptr<DataChannelInterface> dummy(
caller_->CreateDataChannel("data", init));
Negotiate();
WaitForConnection();
@@ -567,9 +570,9 @@
WaitForDataChannelsToOpen(dummy.get(), callee_signaled_data_channels_, 0);
// Create new DataChannels after the negotiation and verify their states.
- rtc::scoped_refptr<DataChannelInterface> caller_dc(
+ webrtc::scoped_refptr<DataChannelInterface> caller_dc(
caller_->CreateDataChannel("hello", init));
- rtc::scoped_refptr<DataChannelInterface> callee_dc(
+ webrtc::scoped_refptr<DataChannelInterface> callee_dc(
callee_->CreateDataChannel("hello", init));
WaitForDataChannelsToOpen(caller_dc.get(), callee_signaled_data_channels_, 1);
@@ -592,7 +595,7 @@
webrtc::DataChannelInit init;
// This DataChannel is for creating the data content in the negotiation.
- rtc::scoped_refptr<DataChannelInterface> dummy(
+ webrtc::scoped_refptr<DataChannelInterface> dummy(
caller_->CreateDataChannel("data", init));
Negotiate();
WaitForConnection();
@@ -601,9 +604,9 @@
WaitForDataChannelsToOpen(dummy.get(), callee_signaled_data_channels_, 0);
// Create new DataChannels after the negotiation and verify their states.
- rtc::scoped_refptr<DataChannelInterface> caller_dc(
+ webrtc::scoped_refptr<DataChannelInterface> caller_dc(
caller_->CreateDataChannel("hello", init));
- rtc::scoped_refptr<DataChannelInterface> callee_dc(
+ webrtc::scoped_refptr<DataChannelInterface> callee_dc(
callee_->CreateDataChannel("hello", init));
WaitForDataChannelsToOpen(caller_dc.get(), callee_signaled_data_channels_, 1);
@@ -624,9 +627,9 @@
webrtc::MockAudioDecoderFactory::CreateEmptyFactory());
webrtc::DataChannelInit init;
- rtc::scoped_refptr<DataChannelInterface> caller_dc_1(
+ webrtc::scoped_refptr<DataChannelInterface> caller_dc_1(
caller_->CreateDataChannel("data", init));
- rtc::scoped_refptr<DataChannelInterface> callee_dc_1(
+ webrtc::scoped_refptr<DataChannelInterface> callee_dc_1(
callee_->CreateDataChannel("data", init));
Negotiate();
@@ -635,9 +638,9 @@
EXPECT_EQ(1, caller_dc_1->id() % 2);
EXPECT_EQ(0, callee_dc_1->id() % 2);
- rtc::scoped_refptr<DataChannelInterface> caller_dc_2(
+ webrtc::scoped_refptr<DataChannelInterface> caller_dc_2(
caller_->CreateDataChannel("data", init));
- rtc::scoped_refptr<DataChannelInterface> callee_dc_2(
+ webrtc::scoped_refptr<DataChannelInterface> callee_dc_2(
callee_->CreateDataChannel("data", init));
EXPECT_EQ(1, caller_dc_2->id() % 2);
@@ -653,9 +656,9 @@
webrtc::DataChannelInit init;
- rtc::scoped_refptr<DataChannelInterface> caller_dc_1(
+ webrtc::scoped_refptr<DataChannelInterface> caller_dc_1(
caller_->CreateDataChannel("data", init));
- rtc::scoped_refptr<DataChannelInterface> caller_dc_2(
+ webrtc::scoped_refptr<DataChannelInterface> caller_dc_2(
caller_->CreateDataChannel("data", init));
Negotiate();
@@ -704,7 +707,7 @@
webrtc::MockAudioDecoderFactory::CreateEmptyFactory());
webrtc::DataChannelInit init;
- rtc::scoped_refptr<DataChannelInterface> caller_dc(
+ webrtc::scoped_refptr<DataChannelInterface> caller_dc(
caller_->CreateDataChannel("data", init));
Negotiate();
@@ -743,7 +746,7 @@
webrtc::MockAudioDecoderFactory::CreateEmptyFactory());
webrtc::DataChannelInit init;
- rtc::scoped_refptr<DataChannelInterface> caller_dc(
+ webrtc::scoped_refptr<DataChannelInterface> caller_dc(
caller_->CreateDataChannel("data", init));
Negotiate();
@@ -770,9 +773,9 @@
webrtc::MockAudioDecoderFactory::CreateEmptyFactory());
webrtc::DataChannelInit init;
- std::vector<rtc::scoped_refptr<DataChannelInterface>> channels;
+ std::vector<webrtc::scoped_refptr<DataChannelInterface>> channels;
for (int i = 0; i <= webrtc::kMaxSctpStreams / 2; i++) {
- rtc::scoped_refptr<DataChannelInterface> caller_dc(
+ webrtc::scoped_refptr<DataChannelInterface> caller_dc(
caller_->CreateDataChannel("data", init));
channels.push_back(std::move(caller_dc));
}
@@ -792,7 +795,7 @@
#endif // WEBRTC_HAVE_SCTP
TEST_P(PeerConnectionEndToEndTest, CanRestartIce) {
- rtc::scoped_refptr<webrtc::AudioDecoderFactory> real_decoder_factory =
+ webrtc::scoped_refptr<webrtc::AudioDecoderFactory> real_decoder_factory =
webrtc::CreateOpusAudioDecoderFactory();
CreatePcs(webrtc::CreateOpusAudioEncoderFactory(),
CreateForwardingMockDecoderFactory(real_decoder_factory.get()));
diff --git a/pc/peer_connection_factory.cc b/pc/peer_connection_factory.cc
index 34cc1da..e62d25a 100644
--- a/pc/peer_connection_factory.cc
+++ b/pc/peer_connection_factory.cc
@@ -68,7 +68,7 @@
namespace webrtc {
-rtc::scoped_refptr<PeerConnectionFactoryInterface>
+scoped_refptr<PeerConnectionFactoryInterface>
CreateModularPeerConnectionFactory(
PeerConnectionFactoryDependencies dependencies) {
// The PeerConnectionFactory must be created on the signaling thread.
@@ -91,7 +91,7 @@
}
// Static
-rtc::scoped_refptr<PeerConnectionFactory> PeerConnectionFactory::Create(
+scoped_refptr<PeerConnectionFactory> PeerConnectionFactory::Create(
PeerConnectionFactoryDependencies dependencies) {
auto context = ConnectionContext::Create(
CreateEnvironment(std::move(dependencies.trials),
@@ -100,11 +100,11 @@
if (!context) {
return nullptr;
}
- return rtc::make_ref_counted<PeerConnectionFactory>(context, &dependencies);
+ return make_ref_counted<PeerConnectionFactory>(context, &dependencies);
}
PeerConnectionFactory::PeerConnectionFactory(
- rtc::scoped_refptr<ConnectionContext> context,
+ scoped_refptr<ConnectionContext> context,
PeerConnectionFactoryDependencies* dependencies)
: context_(context),
codec_vendor_(context_->media_engine(),
@@ -197,11 +197,10 @@
RTC_CHECK_NOTREACHED();
}
-rtc::scoped_refptr<AudioSourceInterface>
-PeerConnectionFactory::CreateAudioSource(const AudioOptions& options) {
+scoped_refptr<AudioSourceInterface> PeerConnectionFactory::CreateAudioSource(
+ const AudioOptions& options) {
RTC_DCHECK(signaling_thread()->IsCurrent());
- rtc::scoped_refptr<LocalAudioSource> source(
- LocalAudioSource::Create(&options));
+ scoped_refptr<LocalAudioSource> source(LocalAudioSource::Create(&options));
return source;
}
@@ -221,7 +220,7 @@
return context_->media_engine();
}
-RTCErrorOr<rtc::scoped_refptr<PeerConnectionInterface>>
+RTCErrorOr<scoped_refptr<PeerConnectionInterface>>
PeerConnectionFactory::CreatePeerConnectionOrError(
const PeerConnectionInterface::RTCConfiguration& configuration,
PeerConnectionDependencies dependencies) {
@@ -239,7 +238,7 @@
return err;
}
- cricket::ServerAddresses stun_servers;
+ ServerAddresses stun_servers;
std::vector<RelayServerConfig> turn_servers;
err = ParseAndValidateIceServersFromConfiguration(configuration, stun_servers,
turn_servers);
@@ -319,33 +318,32 @@
// which will point to the network thread (and not the factory's
// worker_thread()). All such methods have thread checks though, so the code
// should still be clear (outside of macro expansion).
- return rtc::scoped_refptr<PeerConnectionInterface>(
- PeerConnectionProxy::Create(signaling_thread(), network_thread(),
- std::move(pc)));
+ return scoped_refptr<PeerConnectionInterface>(PeerConnectionProxy::Create(
+ signaling_thread(), network_thread(), std::move(pc)));
}
-rtc::scoped_refptr<MediaStreamInterface>
+scoped_refptr<MediaStreamInterface>
PeerConnectionFactory::CreateLocalMediaStream(const std::string& stream_id) {
RTC_DCHECK(signaling_thread()->IsCurrent());
return MediaStreamProxy::Create(signaling_thread(),
MediaStream::Create(stream_id));
}
-rtc::scoped_refptr<VideoTrackInterface> PeerConnectionFactory::CreateVideoTrack(
- rtc::scoped_refptr<VideoTrackSourceInterface> source,
+scoped_refptr<VideoTrackInterface> PeerConnectionFactory::CreateVideoTrack(
+ scoped_refptr<VideoTrackSourceInterface> source,
absl::string_view id) {
RTC_DCHECK(signaling_thread()->IsCurrent());
- rtc::scoped_refptr<VideoTrackInterface> track =
+ scoped_refptr<VideoTrackInterface> track =
VideoTrack::Create(id, source, worker_thread());
return VideoTrackProxy::Create(signaling_thread(), worker_thread(), track);
}
-rtc::scoped_refptr<AudioTrackInterface> PeerConnectionFactory::CreateAudioTrack(
+scoped_refptr<AudioTrackInterface> PeerConnectionFactory::CreateAudioTrack(
const std::string& id,
AudioSourceInterface* source) {
RTC_DCHECK(signaling_thread()->IsCurrent());
- rtc::scoped_refptr<AudioTrackInterface> track =
- AudioTrack::Create(id, rtc::scoped_refptr<AudioSourceInterface>(source));
+ scoped_refptr<AudioTrackInterface> track =
+ AudioTrack::Create(id, scoped_refptr<AudioSourceInterface>(source));
return AudioTrackProxy::Create(signaling_thread(), track);
}
diff --git a/pc/peer_connection_factory.h b/pc/peer_connection_factory.h
index 82fa0db..5b99a69 100644
--- a/pc/peer_connection_factory.h
+++ b/pc/peer_connection_factory.h
@@ -54,12 +54,12 @@
//
// The Dependencies structure allows simple management of all new
// dependencies being added to the PeerConnectionFactory.
- static rtc::scoped_refptr<PeerConnectionFactory> Create(
+ static scoped_refptr<PeerConnectionFactory> Create(
PeerConnectionFactoryDependencies dependencies);
void SetOptions(const Options& options) override;
- RTCErrorOr<rtc::scoped_refptr<PeerConnectionInterface>>
+ RTCErrorOr<scoped_refptr<PeerConnectionInterface>>
CreatePeerConnectionOrError(
const PeerConnectionInterface::RTCConfiguration& configuration,
PeerConnectionDependencies dependencies) override;
@@ -70,17 +70,17 @@
RtpCapabilities GetRtpReceiverCapabilities(
webrtc::MediaType kind) const override;
- rtc::scoped_refptr<MediaStreamInterface> CreateLocalMediaStream(
+ scoped_refptr<MediaStreamInterface> CreateLocalMediaStream(
const std::string& stream_id) override;
- rtc::scoped_refptr<AudioSourceInterface> CreateAudioSource(
+ scoped_refptr<AudioSourceInterface> CreateAudioSource(
const AudioOptions& options) override;
- rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack(
- rtc::scoped_refptr<VideoTrackSourceInterface> video_source,
+ scoped_refptr<VideoTrackInterface> CreateVideoTrack(
+ scoped_refptr<VideoTrackSourceInterface> video_source,
absl::string_view id) override;
- rtc::scoped_refptr<AudioTrackInterface> CreateAudioTrack(
+ scoped_refptr<AudioTrackInterface> CreateAudioTrack(
const std::string& id,
AudioSourceInterface* audio_source) override;
@@ -113,7 +113,7 @@
protected:
// Constructor used by the static Create() method. Modifies the dependencies.
- PeerConnectionFactory(rtc::scoped_refptr<ConnectionContext> context,
+ PeerConnectionFactory(scoped_refptr<ConnectionContext> context,
PeerConnectionFactoryDependencies* dependencies);
// Constructor for use in testing. Ignores the possibility of initialization
@@ -134,7 +134,7 @@
std::unique_ptr<NetworkControllerFactoryInterface>
network_controller_factory);
- rtc::scoped_refptr<ConnectionContext> context_;
+ scoped_refptr<ConnectionContext> context_;
PeerConnectionFactoryInterface::Options options_
RTC_GUARDED_BY(signaling_thread());
CodecVendor codec_vendor_;
diff --git a/pc/peer_connection_factory_proxy.h b/pc/peer_connection_factory_proxy.h
index afa5f2c..e046f66 100644
--- a/pc/peer_connection_factory_proxy.h
+++ b/pc/peer_connection_factory_proxy.h
@@ -32,7 +32,7 @@
BEGIN_PROXY_MAP(PeerConnectionFactory)
PROXY_PRIMARY_THREAD_DESTRUCTOR()
PROXY_METHOD1(void, SetOptions, const Options&)
-PROXY_METHOD2(RTCErrorOr<rtc::scoped_refptr<PeerConnectionInterface>>,
+PROXY_METHOD2(RTCErrorOr<webrtc::scoped_refptr<PeerConnectionInterface>>,
CreatePeerConnectionOrError,
const PeerConnectionInterface::RTCConfiguration&,
PeerConnectionDependencies)
@@ -40,17 +40,17 @@
PROXY_CONSTMETHOD1(RtpCapabilities,
GetRtpReceiverCapabilities,
webrtc::MediaType)
-PROXY_METHOD1(rtc::scoped_refptr<MediaStreamInterface>,
+PROXY_METHOD1(scoped_refptr<MediaStreamInterface>,
CreateLocalMediaStream,
const std::string&)
-PROXY_METHOD1(rtc::scoped_refptr<AudioSourceInterface>,
+PROXY_METHOD1(scoped_refptr<AudioSourceInterface>,
CreateAudioSource,
const AudioOptions&)
-PROXY_METHOD2(rtc::scoped_refptr<VideoTrackInterface>,
+PROXY_METHOD2(scoped_refptr<VideoTrackInterface>,
CreateVideoTrack,
- rtc::scoped_refptr<VideoTrackSourceInterface>,
+ scoped_refptr<VideoTrackSourceInterface>,
absl::string_view)
-PROXY_METHOD2(rtc::scoped_refptr<AudioTrackInterface>,
+PROXY_METHOD2(scoped_refptr<AudioTrackInterface>,
CreateAudioTrack,
const std::string&,
AudioSourceInterface*)
diff --git a/pc/peer_connection_factory_unittest.cc b/pc/peer_connection_factory_unittest.cc
index d9ad9f6..f895496 100644
--- a/pc/peer_connection_factory_unittest.cc
+++ b/pc/peer_connection_factory_unittest.cc
@@ -111,11 +111,10 @@
virtual ~NullPeerConnectionObserver() = default;
void OnSignalingChange(
PeerConnectionInterface::SignalingState new_state) override {}
- void OnAddStream(rtc::scoped_refptr<MediaStreamInterface> stream) override {}
- void OnRemoveStream(
- rtc::scoped_refptr<MediaStreamInterface> stream) override {}
+ void OnAddStream(scoped_refptr<MediaStreamInterface> stream) override {}
+ void OnRemoveStream(scoped_refptr<MediaStreamInterface> stream) override {}
void OnDataChannel(
- rtc::scoped_refptr<DataChannelInterface> data_channel) override {}
+ scoped_refptr<DataChannelInterface> data_channel) override {}
void OnRenegotiationNeeded() override {}
void OnIceConnectionChange(
PeerConnectionInterface::IceConnectionState new_state) override {}
@@ -151,7 +150,7 @@
// parallel.
factory_ = CreatePeerConnectionFactory(
Thread::Current(), Thread::Current(), Thread::Current(),
- rtc::scoped_refptr<AudioDeviceModule>(FakeAudioCaptureModule::Create()),
+ scoped_refptr<AudioDeviceModule>(FakeAudioCaptureModule::Create()),
CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
std::make_unique<VideoEncoderFactoryTemplate<
LibvpxVp8EncoderTemplateAdapter, LibvpxVp9EncoderTemplateAdapter,
@@ -168,7 +167,7 @@
}
protected:
- void VerifyStunServers(cricket::ServerAddresses stun_servers) {
+ void VerifyStunServers(ServerAddresses stun_servers) {
EXPECT_EQ(stun_servers, raw_port_allocator_->stun_servers());
}
@@ -260,7 +259,7 @@
std::unique_ptr<SocketServer> socket_server_;
AutoSocketServerThread main_thread_;
- rtc::scoped_refptr<PeerConnectionFactoryInterface> factory_;
+ scoped_refptr<PeerConnectionFactoryInterface> factory_;
NullPeerConnectionObserver observer_;
std::unique_ptr<FakePortAllocator> port_allocator_;
// Since the PC owns the port allocator after it's been initialized,
@@ -270,7 +269,7 @@
// Since there is no public PeerConnectionFactory API to control RTX usage, need
// to reconstruct factory with our own ConnectionContext.
-rtc::scoped_refptr<PeerConnectionFactoryInterface>
+scoped_refptr<PeerConnectionFactoryInterface>
CreatePeerConnectionFactoryWithRtxDisabled() {
PeerConnectionFactoryDependencies pcf_dependencies;
pcf_dependencies.signaling_thread = Thread::Current();
@@ -291,11 +290,10 @@
OpenH264DecoderTemplateAdapter, Dav1dDecoderTemplateAdapter>>(),
EnableMedia(pcf_dependencies);
- rtc::scoped_refptr<ConnectionContext> context =
+ scoped_refptr<ConnectionContext> context =
ConnectionContext::Create(CreateEnvironment(), &pcf_dependencies);
context->set_use_rtx(false);
- return rtc::make_ref_counted<PeerConnectionFactory>(context,
- &pcf_dependencies);
+ return make_ref_counted<PeerConnectionFactory>(context, &pcf_dependencies);
}
// Verify creation of PeerConnection using internal ADM, video factory and
@@ -309,7 +307,7 @@
InitializeAndroidObjects();
#endif
- rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
+ scoped_refptr<PeerConnectionFactoryInterface> factory(
CreatePeerConnectionFactory(
nullptr /* network_thread */, nullptr /* worker_thread */,
nullptr /* signaling_thread */, nullptr /* default_adm */,
@@ -461,16 +459,16 @@
auto result =
factory_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
ASSERT_TRUE(result.ok());
- cricket::ServerAddresses stun_servers;
+ ServerAddresses stun_servers;
SocketAddress stun1("stun.l.google.com", 19302);
stun_servers.insert(stun1);
VerifyStunServers(stun_servers);
std::vector<RelayServerConfig> turn_servers;
RelayServerConfig turn1("test.com", 1234, kTurnUsername, kTurnPassword,
- cricket::PROTO_UDP);
+ PROTO_UDP);
turn_servers.push_back(turn1);
RelayServerConfig turn2("hello.com", kDefaultStunPort, kTurnUsername,
- kTurnPassword, cricket::PROTO_TCP);
+ kTurnPassword, PROTO_TCP);
turn_servers.push_back(turn2);
VerifyTurnServers(turn_servers);
}
@@ -494,16 +492,16 @@
auto result =
factory_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
ASSERT_TRUE(result.ok());
- cricket::ServerAddresses stun_servers;
+ ServerAddresses stun_servers;
SocketAddress stun1("stun.l.google.com", 19302);
stun_servers.insert(stun1);
VerifyStunServers(stun_servers);
std::vector<RelayServerConfig> turn_servers;
RelayServerConfig turn1("test.com", 1234, kTurnUsername, kTurnPassword,
- cricket::PROTO_UDP);
+ PROTO_UDP);
turn_servers.push_back(turn1);
RelayServerConfig turn2("hello.com", kDefaultStunPort, kTurnUsername,
- kTurnPassword, cricket::PROTO_TCP);
+ kTurnPassword, PROTO_TCP);
turn_servers.push_back(turn2);
VerifyTurnServers(turn_servers);
}
@@ -527,7 +525,7 @@
ASSERT_TRUE(result.ok());
std::vector<RelayServerConfig> turn_servers;
RelayServerConfig turn("test.com", 1234, kTurnUsername, kTurnPassword,
- cricket::PROTO_UDP);
+ PROTO_UDP);
turn_servers.push_back(turn);
VerifyTurnServers(turn_servers);
}
@@ -551,7 +549,7 @@
ASSERT_TRUE(result.ok());
std::vector<RelayServerConfig> turn_servers;
RelayServerConfig turn("hello.com", kDefaultStunPort, kTurnUsername,
- kTurnPassword, cricket::PROTO_TCP);
+ kTurnPassword, PROTO_TCP);
turn_servers.push_back(turn);
VerifyTurnServers(turn_servers);
}
@@ -581,14 +579,14 @@
ASSERT_TRUE(result.ok());
std::vector<RelayServerConfig> turn_servers;
RelayServerConfig turn1("hello.com", kDefaultStunTlsPort, kTurnUsername,
- kTurnPassword, cricket::PROTO_TLS);
+ kTurnPassword, PROTO_TLS);
turn_servers.push_back(turn1);
// TURNS with transport param should be default to tcp.
RelayServerConfig turn2("hello.com", 443, kTurnUsername, kTurnPassword,
- cricket::PROTO_TLS);
+ PROTO_TLS);
turn_servers.push_back(turn2);
RelayServerConfig turn3("hello.com", kDefaultStunTlsPort, kTurnUsername,
- kTurnPassword, cricket::PROTO_TLS);
+ kTurnPassword, PROTO_TLS);
turn_servers.push_back(turn3);
VerifyTurnServers(turn_servers);
}
@@ -616,7 +614,7 @@
auto result =
factory_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
ASSERT_TRUE(result.ok());
- cricket::ServerAddresses stun_servers;
+ ServerAddresses stun_servers;
SocketAddress stun1("1.2.3.4", 1234);
stun_servers.insert(stun1);
SocketAddress stun2("1.2.3.4", 3478);
@@ -629,7 +627,7 @@
std::vector<RelayServerConfig> turn_servers;
RelayServerConfig turn1("2401:fa00:4::", 1234, kTurnUsername, kTurnPassword,
- cricket::PROTO_UDP);
+ PROTO_UDP);
turn_servers.push_back(turn1);
VerifyTurnServers(turn_servers);
}
@@ -637,13 +635,13 @@
// This test verifies the captured stream is rendered locally using a
// local video track.
TEST_F(PeerConnectionFactoryTest, LocalRendering) {
- rtc::scoped_refptr<FakeVideoTrackSource> source =
+ scoped_refptr<FakeVideoTrackSource> source =
FakeVideoTrackSource::Create(/*is_screencast=*/false);
FakeFrameSource frame_source(1280, 720, kNumMicrosecsPerSec / 30);
ASSERT_TRUE(source.get() != NULL);
- rtc::scoped_refptr<VideoTrackInterface> track(
+ scoped_refptr<VideoTrackInterface> track(
factory_->CreateVideoTrack(source, "testlabel"));
ASSERT_TRUE(track.get() != NULL);
FakeVideoTrackRenderer local_renderer(track.get());
@@ -676,7 +674,7 @@
PeerConnectionFactoryDependencies pcf_dependencies;
pcf_dependencies.network_manager = std::move(mock_network_manager);
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pcf =
+ scoped_refptr<PeerConnectionFactoryInterface> pcf =
CreateModularPeerConnectionFactory(std::move(pcf_dependencies));
PeerConnectionInterface::RTCConfiguration config;
@@ -705,7 +703,7 @@
PeerConnectionFactoryDependencies pcf_dependencies;
pcf_dependencies.packet_socket_factory = std::move(mock_socket_factory);
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pcf =
+ scoped_refptr<PeerConnectionFactoryInterface> pcf =
CreateModularPeerConnectionFactory(std::move(pcf_dependencies));
// By default, localhost addresses are ignored, which makes tests fail if test
diff --git a/pc/peer_connection_field_trial_tests.cc b/pc/peer_connection_field_trial_tests.cc
index 0c2352f..9ce3f16 100644
--- a/pc/peer_connection_field_trial_tests.cc
+++ b/pc/peer_connection_field_trial_tests.cc
@@ -93,7 +93,7 @@
Clock* const clock_;
std::unique_ptr<SocketServer> socket_server_;
AutoSocketServerThread main_thread_;
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_ = nullptr;
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory_ = nullptr;
PeerConnectionInterface::RTCConfiguration config_;
};
@@ -113,7 +113,7 @@
const MediaContentDescription* media_description1 =
contents1[0].media_description();
EXPECT_EQ(webrtc::MediaType::VIDEO, media_description1->type());
- const cricket::RtpHeaderExtensions& rtp_header_extensions1 =
+ const RtpHeaderExtensions& rtp_header_extensions1 =
media_description1->rtp_header_extensions();
bool found =
@@ -141,13 +141,13 @@
caller->AddTransceiver(webrtc::MediaType::VIDEO);
auto offer = caller->CreateOffer();
- cricket::ContentInfos& contents1 = offer->description()->contents();
+ ContentInfos& contents1 = offer->description()->contents();
ASSERT_EQ(1u, contents1.size());
MediaContentDescription* media_description1 =
contents1[0].media_description();
EXPECT_EQ(webrtc::MediaType::VIDEO, media_description1->type());
- cricket::RtpHeaderExtensions rtp_header_extensions1 =
+ RtpHeaderExtensions rtp_header_extensions1 =
media_description1->rtp_header_extensions();
bool found1 =
@@ -185,13 +185,13 @@
ASSERT_TRUE(callee->SetRemoteDescription(std::move(offer)));
auto answer = callee->CreateAnswer();
- cricket::ContentInfos& contents2 = answer->description()->contents();
+ ContentInfos& contents2 = answer->description()->contents();
ASSERT_EQ(1u, contents2.size());
MediaContentDescription* media_description2 =
contents2[0].media_description();
EXPECT_EQ(webrtc::MediaType::VIDEO, media_description2->type());
- cricket::RtpHeaderExtensions rtp_header_extensions2 =
+ RtpHeaderExtensions rtp_header_extensions2 =
media_description2->rtp_header_extensions();
bool found2 =
diff --git a/pc/peer_connection_header_extension_unittest.cc b/pc/peer_connection_header_extension_unittest.cc
index fd2c27b..b62d68b 100644
--- a/pc/peer_connection_header_extension_unittest.cc
+++ b/pc/peer_connection_header_extension_unittest.cc
@@ -564,7 +564,7 @@
webrtc::MediaType media_type;
SdpSemantics semantics;
std::tie(media_type, semantics) = info.param;
- return (rtc::StringBuilder("With")
+ return (StringBuilder("With")
<< (semantics == SdpSemantics::kPlanB_DEPRECATED ? "PlanB"
: "UnifiedPlan")
<< "And"
diff --git a/pc/peer_connection_ice_unittest.cc b/pc/peer_connection_ice_unittest.cc
index 20ee339..7d763db 100644
--- a/pc/peer_connection_ice_unittest.cc
+++ b/pc/peer_connection_ice_unittest.cc
@@ -175,9 +175,8 @@
CreateModularPeerConnectionFactory(std::move(pcf_deps));
RTCConfiguration modified_config = config;
- modified_config.set_port_allocator_flags(
- cricket::PORTALLOCATOR_DISABLE_TCP |
- cricket::PORTALLOCATOR_DISABLE_RELAY);
+ modified_config.set_port_allocator_flags(PORTALLOCATOR_DISABLE_TCP |
+ PORTALLOCATOR_DISABLE_RELAY);
modified_config.sdp_semantics = sdp_semantics_;
auto observer = std::make_unique<MockPeerConnectionObserver>();
PeerConnectionDependencies pc_dependencies(observer.get());
@@ -826,7 +825,7 @@
// Chain an operation that will block AddIceCandidate() from executing.
auto answer_observer =
- rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ make_ref_counted<MockCreateSessionDescriptionObserver>();
callee->pc()->CreateAnswer(answer_observer.get(), RTCOfferAnswerOptions());
auto jsep_candidate =
@@ -880,7 +879,7 @@
// Chain an operation that will block AddIceCandidate() from executing.
auto answer_observer =
- rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ make_ref_counted<MockCreateSessionDescriptionObserver>();
callee->pc()->CreateAnswer(answer_observer.get(), RTCOfferAnswerOptions());
auto jsep_candidate =
@@ -1482,8 +1481,8 @@
std::unique_ptr<SocketServer> socket_server_;
AutoSocketServerThread main_thread_;
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_ = nullptr;
- rtc::scoped_refptr<PeerConnectionInterface> pc_ = nullptr;
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory_ = nullptr;
+ scoped_refptr<PeerConnectionInterface> pc_ = nullptr;
FakePortAllocator* port_allocator_ = nullptr;
MockPeerConnectionObserver observer_;
diff --git a/pc/peer_connection_integrationtest.cc b/pc/peer_connection_integrationtest.cc
index 0e732b6..1c1f1ae 100644
--- a/pc/peer_connection_integrationtest.cc
+++ b/pc/peer_connection_integrationtest.cc
@@ -290,7 +290,7 @@
void TestDtmfFromSenderToReceiver(PeerConnectionIntegrationWrapper* sender,
PeerConnectionIntegrationWrapper* receiver) {
// We should be able to get a DTMF sender from the local sender.
- rtc::scoped_refptr<DtmfSenderInterface> dtmf_sender =
+ scoped_refptr<DtmfSenderInterface> dtmf_sender =
sender->pc()->GetSenders().at(0)->GetDtmfSender();
ASSERT_TRUE(dtmf_sender);
DummyDtmfObserver observer;
@@ -429,7 +429,7 @@
CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/true));
ConnectFakeSignaling();
// Add one-directional video, from caller to callee.
- rtc::scoped_refptr<VideoTrackInterface> caller_track =
+ scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack();
caller()->AddTrack(caller_track);
PeerConnectionInterface::RTCOfferAnswerOptions options;
@@ -456,7 +456,7 @@
CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/false));
ConnectFakeSignaling();
// Add one-directional video, from callee to caller.
- rtc::scoped_refptr<VideoTrackInterface> callee_track =
+ scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack();
callee()->AddTrack(callee_track);
PeerConnectionInterface::RTCOfferAnswerOptions options;
@@ -481,7 +481,7 @@
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
// Add one-directional video, from caller to callee.
- rtc::scoped_refptr<VideoTrackInterface> caller_track =
+ scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack();
caller()->AddTrack(caller_track);
caller()->CreateAndSetAndSignalOffer();
@@ -490,7 +490,7 @@
IsRtcOk());
// Add receive video.
- rtc::scoped_refptr<VideoTrackInterface> callee_track =
+ scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack();
callee()->AddTrack(callee_track);
caller()->CreateAndSetAndSignalOffer();
@@ -509,7 +509,7 @@
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
// Add one-directional video, from callee to caller.
- rtc::scoped_refptr<VideoTrackInterface> callee_track =
+ scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack();
callee()->AddTrack(callee_track);
caller()->CreateAndSetAndSignalOffer();
@@ -518,7 +518,7 @@
IsRtcOk());
// Add send video.
- rtc::scoped_refptr<VideoTrackInterface> caller_track =
+ scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack();
caller()->AddTrack(caller_track);
caller()->CreateAndSetAndSignalOffer();
@@ -537,15 +537,15 @@
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
// Add send video, from caller to callee.
- rtc::scoped_refptr<VideoTrackInterface> caller_track =
+ scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack();
- rtc::scoped_refptr<RtpSenderInterface> caller_sender =
+ scoped_refptr<RtpSenderInterface> caller_sender =
caller()->AddTrack(caller_track);
// Add receive video, from callee to caller.
- rtc::scoped_refptr<VideoTrackInterface> callee_track =
+ scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack();
- rtc::scoped_refptr<RtpSenderInterface> callee_sender =
+ scoped_refptr<RtpSenderInterface> callee_sender =
callee()->AddTrack(callee_track);
caller()->CreateAndSetAndSignalOffer();
ASSERT_THAT(
@@ -573,15 +573,15 @@
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
// Add send video, from caller to callee.
- rtc::scoped_refptr<VideoTrackInterface> caller_track =
+ scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack();
- rtc::scoped_refptr<RtpSenderInterface> caller_sender =
+ scoped_refptr<RtpSenderInterface> caller_sender =
caller()->AddTrack(caller_track);
// Add receive video, from callee to caller.
- rtc::scoped_refptr<VideoTrackInterface> callee_track =
+ scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack();
- rtc::scoped_refptr<RtpSenderInterface> callee_sender =
+ scoped_refptr<RtpSenderInterface> callee_sender =
callee()->AddTrack(callee_track);
caller()->CreateAndSetAndSignalOffer();
ASSERT_THAT(
@@ -981,7 +981,7 @@
if (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED) {
caller()->SetGeneratedSdpMunger(
[](std::unique_ptr<SessionDescriptionInterface>& sdp) {
- for (cricket::ContentInfo& content : sdp->description()->contents()) {
+ for (ContentInfo& content : sdp->description()->contents()) {
if (IsVideoContent(&content)) {
content.rejected = true;
}
@@ -1021,9 +1021,8 @@
ConnectFakeSignaling();
// Add audio track, do normal offer/answer.
- rtc::scoped_refptr<AudioTrackInterface> track =
- caller()->CreateLocalAudioTrack();
- rtc::scoped_refptr<RtpSenderInterface> sender =
+ scoped_refptr<AudioTrackInterface> track = caller()->CreateLocalAudioTrack();
+ scoped_refptr<RtpSenderInterface> sender =
caller()->pc()->AddTrack(track, {"stream"}).MoveValue();
caller()->CreateAndSetAndSignalOffer();
ASSERT_THAT(
@@ -1106,8 +1105,7 @@
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
// Add one-directional video, from caller to callee.
- rtc::scoped_refptr<VideoTrackInterface> track =
- caller()->CreateLocalVideoTrack();
+ scoped_refptr<VideoTrackInterface> track = caller()->CreateLocalVideoTrack();
RtpTransceiverInit video_transceiver_init;
video_transceiver_init.stream_ids = {"video1"};
@@ -1122,7 +1120,7 @@
// Add receive direction.
video_sender->SetDirectionWithError(RtpTransceiverDirection::kSendRecv);
- rtc::scoped_refptr<VideoTrackInterface> callee_track =
+ scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack();
callee()->AddTrack(callee_track);
@@ -1170,7 +1168,7 @@
sdp->description()->RemoveGroupByName("BUNDLE");
for (ContentInfo& content : sdp->description()->contents()) {
MediaContentDescription* media = content.media_description();
- cricket::RtpHeaderExtensions extensions = media->rtp_header_extensions();
+ RtpHeaderExtensions extensions = media->rtp_header_extensions();
extensions.erase(std::remove_if(extensions.begin(), extensions.end(),
[](const RtpExtension& extension) {
return extension.uri ==
@@ -1219,7 +1217,7 @@
int pt = 96;
for (ContentInfo& content : sdp->description()->contents()) {
MediaContentDescription* media = content.media_description();
- cricket::RtpHeaderExtensions extensions = media->rtp_header_extensions();
+ RtpHeaderExtensions extensions = media->rtp_header_extensions();
extensions.erase(std::remove_if(extensions.begin(), extensions.end(),
[](const RtpExtension& extension) {
return extension.uri ==
@@ -1322,7 +1320,7 @@
static void MakeSpecCompliantMaxBundleOffer(
std::unique_ptr<SessionDescriptionInterface>& sdp) {
bool first = true;
- for (cricket::ContentInfo& content : sdp->description()->contents()) {
+ for (ContentInfo& content : sdp->description()->contents()) {
if (first) {
first = false;
continue;
@@ -1330,15 +1328,14 @@
content.bundle_only = true;
}
first = true;
- for (cricket::TransportInfo& transport :
- sdp->description()->transport_infos()) {
+ for (TransportInfo& transport : sdp->description()->transport_infos()) {
if (first) {
first = false;
continue;
}
transport.description.ice_ufrag.clear();
transport.description.ice_pwd.clear();
- transport.description.connection_role = cricket::CONNECTIONROLE_NONE;
+ transport.description.connection_role = CONNECTIONROLE_NONE;
transport.description.identity_fingerprint.reset(nullptr);
}
}
@@ -1517,8 +1514,7 @@
audio_sender_1->track()->id(), video_sender_1->track()->id(),
audio_sender_2->track()->id(), video_sender_2->track()->id()};
- rtc::scoped_refptr<const RTCStatsReport> caller_report =
- caller()->NewGetStats();
+ scoped_refptr<const RTCStatsReport> caller_report = caller()->NewGetStats();
ASSERT_TRUE(caller_report);
auto outbound_stream_stats =
caller_report->GetStatsOfType<RTCOutboundRtpStreamStats>();
@@ -1542,8 +1538,7 @@
}
EXPECT_THAT(outbound_track_ids, UnorderedElementsAreArray(track_ids));
- rtc::scoped_refptr<const RTCStatsReport> callee_report =
- callee()->NewGetStats();
+ scoped_refptr<const RTCStatsReport> callee_report = callee()->NewGetStats();
ASSERT_TRUE(callee_report);
auto inbound_stream_stats =
callee_report->GetStatsOfType<RTCInboundRtpStreamStats>();
@@ -1583,7 +1578,7 @@
// We received a frame, so we should have nonzero "bytes received" stats for
// the unsignaled stream, if stats are working for it.
- rtc::scoped_refptr<const RTCStatsReport> report = callee()->NewGetStats();
+ scoped_refptr<const RTCStatsReport> report = callee()->NewGetStats();
ASSERT_NE(nullptr, report);
auto inbound_stream_stats =
report->GetStatsOfType<RTCInboundRtpStreamStats>();
@@ -1635,7 +1630,7 @@
media_expectations.CalleeExpectsSomeVideo(1);
ASSERT_TRUE(ExpectNewFrames(media_expectations));
- rtc::scoped_refptr<const RTCStatsReport> report = callee()->NewGetStats();
+ scoped_refptr<const RTCStatsReport> report = callee()->NewGetStats();
ASSERT_NE(nullptr, report);
auto inbound_rtps = report->GetStatsOfType<RTCInboundRtpStreamStats>();
@@ -1878,9 +1873,9 @@
IsRtcOk());
}
-constexpr int kOnlyLocalPorts = cricket::PORTALLOCATOR_DISABLE_STUN |
- cricket::PORTALLOCATOR_DISABLE_RELAY |
- cricket::PORTALLOCATOR_DISABLE_TCP;
+constexpr int kOnlyLocalPorts = PORTALLOCATOR_DISABLE_STUN |
+ PORTALLOCATOR_DISABLE_RELAY |
+ PORTALLOCATOR_DISABLE_TCP;
// Use a mock resolver to resolve the hostname back to the original IP on both
// sides and check that the ICE connection connects.
@@ -1976,7 +1971,7 @@
}
bool TestIPv6() {
- return (port_allocator_flags_ & cricket::PORTALLOCATOR_ENABLE_IPV6);
+ return (port_allocator_flags_ & PORTALLOCATOR_ENABLE_IPV6);
}
std::vector<SocketAddress> CallerAddresses() {
@@ -2033,7 +2028,7 @@
// Block connections to/from the caller and wait for ICE to become
// disconnected.
for (const auto& caller_address : CallerAddresses()) {
- firewall()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, caller_address);
+ firewall()->AddRule(false, FP_ANY, FD_ANY, caller_address);
}
PeerConnectionInterface::RTCConfiguration config;
@@ -2115,14 +2110,14 @@
kIceCandidatePairHostPublicHostPublic));
}
-constexpr uint32_t kFlagsIPv4NoStun = cricket::PORTALLOCATOR_DISABLE_TCP |
- cricket::PORTALLOCATOR_DISABLE_STUN |
- cricket::PORTALLOCATOR_DISABLE_RELAY;
+constexpr uint32_t kFlagsIPv4NoStun = PORTALLOCATOR_DISABLE_TCP |
+ PORTALLOCATOR_DISABLE_STUN |
+ PORTALLOCATOR_DISABLE_RELAY;
constexpr uint32_t kFlagsIPv6NoStun =
- cricket::PORTALLOCATOR_DISABLE_TCP | cricket::PORTALLOCATOR_DISABLE_STUN |
- cricket::PORTALLOCATOR_ENABLE_IPV6 | cricket::PORTALLOCATOR_DISABLE_RELAY;
+ PORTALLOCATOR_DISABLE_TCP | PORTALLOCATOR_DISABLE_STUN |
+ PORTALLOCATOR_ENABLE_IPV6 | PORTALLOCATOR_DISABLE_RELAY;
constexpr uint32_t kFlagsIPv4Stun =
- cricket::PORTALLOCATOR_DISABLE_TCP | cricket::PORTALLOCATOR_DISABLE_RELAY;
+ PORTALLOCATOR_DISABLE_TCP | PORTALLOCATOR_DISABLE_RELAY;
INSTANTIATE_TEST_SUITE_P(
PeerConnectionIntegrationTest,
@@ -2254,11 +2249,11 @@
// Sanity check that ICE renomination was actually negotiated.
const SessionDescription* desc =
caller()->pc()->local_description()->description();
- for (const cricket::TransportInfo& info : desc->transport_infos()) {
+ for (const TransportInfo& info : desc->transport_infos()) {
ASSERT_THAT(info.description.transport_options, Contains("renomination"));
}
desc = callee()->pc()->local_description()->description();
- for (const cricket::TransportInfo& info : desc->transport_infos()) {
+ for (const TransportInfo& info : desc->transport_infos()) {
ASSERT_THAT(info.description.transport_options, Contains("renomination"));
}
MediaExpectations media_expectations;
@@ -2600,8 +2595,7 @@
caller()->AddAudioTrack();
// Call getStats, assert there are no candidates.
- rtc::scoped_refptr<const RTCStatsReport> first_report =
- caller()->NewGetStats();
+ scoped_refptr<const RTCStatsReport> first_report = caller()->NewGetStats();
ASSERT_TRUE(first_report);
auto first_candidate_stats =
first_report->GetStatsOfType<RTCLocalIceCandidateStats>();
@@ -2611,8 +2605,7 @@
// callee.
caller()->CreateAndSetAndSignalOffer();
// Call getStats again, assert there are candidates now.
- rtc::scoped_refptr<const RTCStatsReport> second_report =
- caller()->NewGetStats();
+ scoped_refptr<const RTCStatsReport> second_report = caller()->NewGetStats();
ASSERT_TRUE(second_report);
auto second_candidate_stats =
second_report->GetStatsOfType<RTCLocalIceCandidateStats>();
@@ -2637,8 +2630,7 @@
IsRtcOk());
// Call getStats, assert there are no candidates.
- rtc::scoped_refptr<const RTCStatsReport> first_report =
- caller()->NewGetStats();
+ scoped_refptr<const RTCStatsReport> first_report = caller()->NewGetStats();
ASSERT_TRUE(first_report);
auto first_candidate_stats =
first_report->GetStatsOfType<RTCRemoteIceCandidateStats>();
@@ -2658,8 +2650,7 @@
ASSERT_TRUE(result.value().ok());
// Call getStats again, assert there is a remote candidate now.
- rtc::scoped_refptr<const RTCStatsReport> second_report =
- caller()->NewGetStats();
+ scoped_refptr<const RTCStatsReport> second_report = caller()->NewGetStats();
ASSERT_TRUE(second_report);
auto second_candidate_stats =
second_report->GetStatsOfType<RTCRemoteIceCandidateStats>();
@@ -2731,7 +2722,7 @@
// Enable TCP for the fake turn server.
CreateTurnServer(turn_server_internal_address, turn_server_external_address,
- cricket::PROTO_TCP);
+ PROTO_TCP);
PeerConnectionInterface::IceServer ice_server;
ice_server.urls.push_back("turn:88.88.88.0:3478?transport=tcp");
@@ -2781,7 +2772,7 @@
// Enable TCP-TLS for the fake turn server. We need to pass in 88.88.88.0 so
// that host name verification passes on the fake certificate.
CreateTurnServer(turn_server_internal_address, turn_server_external_address,
- cricket::PROTO_TLS, "88.88.88.0");
+ PROTO_TLS, "88.88.88.0");
PeerConnectionInterface::IceServer ice_server;
ice_server.urls.push_back("turns:88.88.88.0:3478?transport=tcp");
@@ -2847,7 +2838,7 @@
/*reset_decoder_factory=*/false);
ASSERT_TRUE(wrapper);
wrapper->CreateDataChannel();
- auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockSetSessionDescriptionObserver>();
wrapper->pc()->SetLocalDescription(observer.get(),
wrapper->CreateOfferAndWait().release());
}
@@ -3103,9 +3094,8 @@
ConnectFakeSignaling();
// Add track using stream 1, do offer/answer.
- rtc::scoped_refptr<AudioTrackInterface> track =
- caller()->CreateLocalAudioTrack();
- rtc::scoped_refptr<RtpSenderInterface> sender =
+ scoped_refptr<AudioTrackInterface> track = caller()->CreateLocalAudioTrack();
+ scoped_refptr<RtpSenderInterface> sender =
caller()->AddTrack(track, {"stream_1"});
caller()->CreateAndSetAndSignalOffer();
ASSERT_THAT(
@@ -3566,7 +3556,7 @@
SetSignalIceCandidates(false); // Workaround candidate outrace sdp.
caller()->AddVideoTrack();
callee()->AddVideoTrack();
- auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockSetSessionDescriptionObserver>();
callee()->pc()->SetLocalDescription(observer.get(),
callee()->CreateOfferAndWait().release());
EXPECT_THAT(
@@ -3587,8 +3577,7 @@
ASSERT_TRUE(CreatePeerConnectionWrappersWithConfig(config, config));
- auto sld_observer =
- rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ auto sld_observer = make_ref_counted<MockSetSessionDescriptionObserver>();
callee()->pc()->SetLocalDescription(sld_observer.get(),
callee()->CreateOfferAndWait().release());
EXPECT_THAT(
@@ -3596,8 +3585,7 @@
IsRtcOk());
EXPECT_EQ(sld_observer->error(), "");
- auto srd_observer =
- rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ auto srd_observer = make_ref_counted<MockSetSessionDescriptionObserver>();
callee()->pc()->SetRemoteDescription(
srd_observer.get(), caller()->CreateOfferAndWait().release());
EXPECT_THAT(
@@ -4159,7 +4147,7 @@
CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/true));
ConnectFakeSignaling();
// Add one-directional video, from caller to callee.
- rtc::scoped_refptr<VideoTrackInterface> caller_track =
+ scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack();
auto sender = caller()->AddTrack(caller_track);
PeerConnectionInterface::RTCOfferAnswerOptions options;
@@ -4191,7 +4179,7 @@
CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/true));
ConnectFakeSignaling();
// Add one-directional video, from caller to callee.
- rtc::scoped_refptr<VideoTrackInterface> caller_track =
+ scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack();
auto sender = caller()->AddTrack(caller_track);
PeerConnectionInterface::RTCOfferAnswerOptions options;
@@ -4231,7 +4219,7 @@
}
int NacksReceivedCount(PeerConnectionIntegrationWrapper& pc) {
- rtc::scoped_refptr<const RTCStatsReport> report = pc.NewGetStats();
+ scoped_refptr<const RTCStatsReport> report = pc.NewGetStats();
auto sender_stats = report->GetStatsOfType<RTCOutboundRtpStreamStats>();
if (sender_stats.size() != 1) {
ADD_FAILURE();
@@ -4244,7 +4232,7 @@
}
int NacksSentCount(PeerConnectionIntegrationWrapper& pc) {
- rtc::scoped_refptr<const RTCStatsReport> report = pc.NewGetStats();
+ scoped_refptr<const RTCStatsReport> report = pc.NewGetStats();
auto receiver_stats = report->GetStatsOfType<RTCInboundRtpStreamStats>();
if (receiver_stats.size() != 1) {
ADD_FAILURE();
@@ -4579,7 +4567,7 @@
IsRtcOk());
for (const auto& pair : {caller(), callee()}) {
- rtc::scoped_refptr<const RTCStatsReport> report = pair->NewGetStats();
+ scoped_refptr<const RTCStatsReport> report = pair->NewGetStats();
ASSERT_TRUE(report);
auto inbound_stream_stats =
report->GetStatsOfType<RTCInboundRtpStreamStats>();
@@ -4641,7 +4629,7 @@
IsRtcOk());
for (const auto& pair : {caller(), callee()}) {
- rtc::scoped_refptr<const RTCStatsReport> report = pair->NewGetStats();
+ scoped_refptr<const RTCStatsReport> report = pair->NewGetStats();
ASSERT_TRUE(report);
auto inbound_stream_stats =
report->GetStatsOfType<RTCInboundRtpStreamStats>();
@@ -4694,7 +4682,7 @@
IsRtcOk());
for (const auto& pair : {caller(), callee()}) {
- rtc::scoped_refptr<const RTCStatsReport> report = pair->NewGetStats();
+ scoped_refptr<const RTCStatsReport> report = pair->NewGetStats();
ASSERT_TRUE(report);
auto inbound_stream_stats =
report->GetStatsOfType<RTCInboundRtpStreamStats>();
@@ -4841,8 +4829,7 @@
"a=rtcp-fb:98 transport-cc\r\n"
"a=rtpmap:99 rtx/90000\r\n"
"a=fmtp:99 apt=96\r\n";
- auto srd_observer =
- rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ auto srd_observer = make_ref_counted<MockSetSessionDescriptionObserver>();
std::unique_ptr<SessionDescriptionInterface> remote_offer =
CreateSessionDescription(SdpType::kOffer, remote_offer_string);
EXPECT_TRUE(caller()->SetRemoteDescription(std::move(remote_offer)));
diff --git a/pc/peer_connection_interface_unittest.cc b/pc/peer_connection_interface_unittest.cc
index 1350d72..d56492a 100644
--- a/pc/peer_connection_interface_unittest.cc
+++ b/pc/peer_connection_interface_unittest.cc
@@ -456,8 +456,7 @@
// behavior.
std::vector<std::string> GetUfrags(const SessionDescriptionInterface* desc) {
std::vector<std::string> ufrags;
- for (const cricket::TransportInfo& info :
- desc->description()->transport_infos()) {
+ for (const TransportInfo& info : desc->description()->transport_infos()) {
ufrags.push_back(info.description.ice_ufrag);
}
return ufrags;
@@ -479,7 +478,7 @@
bool ContainsTrack(const std::vector<StreamParams>& streams,
const std::string& stream_id,
const std::string& track_id) {
- for (const cricket::StreamParams& params : streams) {
+ for (const StreamParams& params : streams) {
if (params.first_stream_id() == stream_id && params.id == track_id) {
return true;
}
@@ -489,7 +488,7 @@
// Check if `senders` contains the specified sender, by id.
bool ContainsSender(
- const std::vector<rtc::scoped_refptr<RtpSenderInterface>>& senders,
+ const std::vector<scoped_refptr<RtpSenderInterface>>& senders,
const std::string& id) {
for (const auto& sender : senders) {
if (sender->id() == id) {
@@ -501,7 +500,7 @@
// Check if `senders` contains the specified sender, by id and stream id.
bool ContainsSender(
- const std::vector<rtc::scoped_refptr<RtpSenderInterface>>& senders,
+ const std::vector<scoped_refptr<RtpSenderInterface>>& senders,
const std::string& id,
const std::string& stream_id) {
for (const auto& sender : senders) {
@@ -516,24 +515,22 @@
// CreateStreamCollection(1) creates a collection that
// correspond to kSdpStringWithStream1.
// CreateStreamCollection(2) correspond to kSdpStringWithStream1And2.
-rtc::scoped_refptr<StreamCollection> CreateStreamCollection(
- int number_of_streams,
- int tracks_per_stream) {
- rtc::scoped_refptr<StreamCollection> local_collection(
- StreamCollection::Create());
+scoped_refptr<StreamCollection> CreateStreamCollection(int number_of_streams,
+ int tracks_per_stream) {
+ scoped_refptr<StreamCollection> local_collection(StreamCollection::Create());
for (int i = 0; i < number_of_streams; ++i) {
- rtc::scoped_refptr<MediaStreamInterface> stream(
+ scoped_refptr<MediaStreamInterface> stream(
MediaStream::Create(kStreams[i]));
for (int j = 0; j < tracks_per_stream; ++j) {
// Add a local audio track.
- rtc::scoped_refptr<AudioTrackInterface> audio_track(
+ scoped_refptr<AudioTrackInterface> audio_track(
AudioTrack::Create(kAudioTracks[i * tracks_per_stream + j], nullptr));
stream->AddTrack(audio_track);
// Add a local video track.
- rtc::scoped_refptr<VideoTrackInterface> video_track(VideoTrack::Create(
+ scoped_refptr<VideoTrackInterface> video_track(VideoTrack::Create(
kVideoTracks[i * tracks_per_stream + j],
FakeVideoTrackSource::Create(), Thread::Current()));
stream->AddTrack(video_track);
@@ -609,7 +606,7 @@
// exercised by these unittest.
class PeerConnectionFactoryForTest : public PeerConnectionFactory {
public:
- static rtc::scoped_refptr<PeerConnectionFactoryForTest>
+ static scoped_refptr<PeerConnectionFactoryForTest>
CreatePeerConnectionFactoryForTest() {
PeerConnectionFactoryDependencies dependencies;
dependencies.worker_thread = Thread::Current();
@@ -623,14 +620,14 @@
EnableMediaWithDefaults(dependencies);
dependencies.event_log_factory = std::make_unique<RtcEventLogFactory>();
- return rtc::make_ref_counted<PeerConnectionFactoryForTest>(
+ return make_ref_counted<PeerConnectionFactoryForTest>(
std::move(dependencies));
}
using PeerConnectionFactory::PeerConnectionFactory;
private:
- rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
+ scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
};
// TODO(steveanton): Convert to use the new PeerConnectionWrapper.
@@ -651,7 +648,7 @@
fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
pc_factory_ = CreatePeerConnectionFactory(
Thread::Current(), Thread::Current(), Thread::Current(),
- rtc::scoped_refptr<AudioDeviceModule>(fake_audio_capture_module_),
+ scoped_refptr<AudioDeviceModule>(fake_audio_capture_module_),
CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
std::make_unique<VideoEncoderFactoryTemplate<
LibvpxVp8EncoderTemplateAdapter, LibvpxVp9EncoderTemplateAdapter,
@@ -787,7 +784,7 @@
observer_.SetPeerConnectionInterface(nullptr);
}
- rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack(
+ scoped_refptr<VideoTrackInterface> CreateVideoTrack(
const std::string& label) {
return pc_factory_->CreateVideoTrack(FakeVideoTrackSource::Create(), label);
}
@@ -800,13 +797,13 @@
}
void AddVideoStream(const std::string& label) {
- rtc::scoped_refptr<MediaStreamInterface> stream(
+ scoped_refptr<MediaStreamInterface> stream(
pc_factory_->CreateLocalMediaStream(label));
stream->AddTrack(CreateVideoTrack(label + "v0"));
ASSERT_TRUE(pc_->AddStream(stream.get()));
}
- rtc::scoped_refptr<AudioTrackInterface> CreateAudioTrack(
+ scoped_refptr<AudioTrackInterface> CreateAudioTrack(
const std::string& label) {
return pc_factory_->CreateAudioTrack(label, nullptr);
}
@@ -819,7 +816,7 @@
}
void AddAudioStream(const std::string& label) {
- rtc::scoped_refptr<MediaStreamInterface> stream(
+ scoped_refptr<MediaStreamInterface> stream(
pc_factory_->CreateLocalMediaStream(label));
stream->AddTrack(CreateAudioTrack(label + "a0"));
ASSERT_TRUE(pc_->AddStream(stream.get()));
@@ -829,14 +826,14 @@
const std::string& audio_track_label,
const std::string& video_track_label) {
// Create a local stream.
- rtc::scoped_refptr<MediaStreamInterface> stream(
+ scoped_refptr<MediaStreamInterface> stream(
pc_factory_->CreateLocalMediaStream(stream_id));
stream->AddTrack(CreateAudioTrack(audio_track_label));
stream->AddTrack(CreateVideoTrack(video_track_label));
ASSERT_TRUE(pc_->AddStream(stream.get()));
}
- rtc::scoped_refptr<RtpReceiverInterface> GetFirstReceiverOfType(
+ scoped_refptr<RtpReceiverInterface> GetFirstReceiverOfType(
webrtc::MediaType media_type) {
for (auto receiver : pc_->GetReceivers()) {
if (receiver->media_type() == media_type) {
@@ -849,8 +846,7 @@
bool DoCreateOfferAnswer(std::unique_ptr<SessionDescriptionInterface>* desc,
const RTCOfferAnswerOptions* options,
bool offer) {
- auto observer =
- rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockCreateSessionDescriptionObserver>();
if (offer) {
pc_->CreateOffer(observer.get(),
options ? *options : RTCOfferAnswerOptions());
@@ -879,7 +875,7 @@
bool DoSetSessionDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
bool local) {
- auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockSetSessionDescriptionObserver>();
if (local) {
pc_->SetLocalDescription(observer.get(), desc.release());
} else {
@@ -908,7 +904,7 @@
// It does not verify the values in the StatReports since a RTCP packet might
// be required.
bool DoGetStats(MediaStreamTrackInterface* track) {
- auto observer = rtc::make_ref_counted<MockStatsObserver>();
+ auto observer = make_ref_counted<MockStatsObserver>();
if (!pc_->GetStats(observer.get(), track,
PeerConnectionInterface::kStatsOutputLevelStandard))
return false;
@@ -921,7 +917,7 @@
// Call the standards-compliant GetStats function.
bool DoGetRTCStats() {
- auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>();
+ auto callback = make_ref_counted<MockRTCStatsCollectorCallback>();
pc_->GetStats(callback.get());
EXPECT_THAT(
WaitUntil([&] { return callback->called(); }, ::testing::IsTrue(),
@@ -1103,7 +1099,7 @@
std::string mediastream_id = kStreams[0];
- rtc::scoped_refptr<MediaStreamInterface> stream(
+ scoped_refptr<MediaStreamInterface> stream(
MediaStream::Create(mediastream_id));
reference_collection_->AddStream(stream);
@@ -1133,14 +1129,14 @@
void AddAudioTrack(const std::string& track_id,
MediaStreamInterface* stream) {
- rtc::scoped_refptr<AudioTrackInterface> audio_track(
+ scoped_refptr<AudioTrackInterface> audio_track(
AudioTrack::Create(track_id, nullptr));
ASSERT_TRUE(stream->AddTrack(audio_track));
}
void AddVideoTrack(const std::string& track_id,
MediaStreamInterface* stream) {
- rtc::scoped_refptr<VideoTrackInterface> video_track(VideoTrack::Create(
+ scoped_refptr<VideoTrackInterface> video_track(VideoTrack::Create(
track_id, FakeVideoTrackSource::Create(), Thread::Current()));
ASSERT_TRUE(stream->AddTrack(video_track));
}
@@ -1186,8 +1182,7 @@
std::unique_ptr<SessionDescriptionInterface> CreateOfferWithOptions(
const RTCOfferAnswerOptions& offer_answer_options) {
RTC_DCHECK(pc_);
- auto observer =
- rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockCreateSessionDescriptionObserver>();
pc_->CreateOffer(observer.get(), offer_answer_options);
EXPECT_THAT(
WaitUntil([&] { return observer->called(); }, ::testing::IsTrue(),
@@ -1254,13 +1249,13 @@
std::unique_ptr<VirtualSocketServer> vss_;
AutoSocketServerThread main_;
- rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
+ scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
FakePortAllocator* port_allocator_ = nullptr;
FakeRTCCertificateGenerator* fake_certificate_generator_ = nullptr;
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
- rtc::scoped_refptr<PeerConnectionInterface> pc_;
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
+ scoped_refptr<PeerConnectionInterface> pc_;
MockPeerConnectionObserver observer_;
- rtc::scoped_refptr<StreamCollection> reference_collection_;
+ scoped_refptr<StreamCollection> reference_collection_;
const SdpSemantics sdp_semantics_;
};
@@ -1372,7 +1367,7 @@
config.prune_turn_ports = true;
// Create the PC factory and PC with the above config.
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory(
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory(
CreatePeerConnectionFactory(
Thread::Current(), Thread::Current(), Thread::Current(),
fake_audio_capture_module_, CreateBuiltinAudioEncoderFactory(),
@@ -1449,11 +1444,10 @@
ASSERT_EQ(2u, pc_->local_streams()->count());
// Test we can add multiple local streams to one peerconnection.
- rtc::scoped_refptr<MediaStreamInterface> stream(
+ scoped_refptr<MediaStreamInterface> stream(
pc_factory_->CreateLocalMediaStream(kStreamId3));
- rtc::scoped_refptr<AudioTrackInterface> audio_track(
- pc_factory_->CreateAudioTrack(
- kStreamId3, static_cast<AudioSourceInterface*>(nullptr)));
+ scoped_refptr<AudioTrackInterface> audio_track(pc_factory_->CreateAudioTrack(
+ kStreamId3, static_cast<AudioSourceInterface*>(nullptr)));
stream->AddTrack(audio_track);
EXPECT_TRUE(pc_->AddStream(stream.get()));
EXPECT_EQ(3u, pc_->local_streams()->count());
@@ -1518,9 +1512,9 @@
// in peerconnection_jsep_unittests.cc
TEST_F(PeerConnectionInterfaceTestPlanB, AddTrackRemoveTrack) {
CreatePeerConnectionWithoutDtls();
- rtc::scoped_refptr<AudioTrackInterface> audio_track(
+ scoped_refptr<AudioTrackInterface> audio_track(
CreateAudioTrack("audio_track"));
- rtc::scoped_refptr<VideoTrackInterface> video_track(
+ scoped_refptr<VideoTrackInterface> video_track(
CreateVideoTrack("video_track"));
auto audio_sender = pc_->AddTrack(audio_track, {kStreamId1}).MoveValue();
auto video_sender = pc_->AddTrack(video_track, {kStreamId1}).MoveValue();
@@ -1573,9 +1567,9 @@
// Test for AddTrack with init_send_encoding.
TEST_F(PeerConnectionInterfaceTestPlanB, AddTrackWithSendEncodings) {
CreatePeerConnectionWithoutDtls();
- rtc::scoped_refptr<AudioTrackInterface> audio_track(
+ scoped_refptr<AudioTrackInterface> audio_track(
CreateAudioTrack("audio_track"));
- rtc::scoped_refptr<VideoTrackInterface> video_track(
+ scoped_refptr<VideoTrackInterface> video_track(
CreateVideoTrack("video_track"));
RtpEncodingParameters audio_encodings;
audio_encodings.active = false;
@@ -1623,9 +1617,9 @@
// expecting a random stream ID to be generated.
TEST_P(PeerConnectionInterfaceTest, AddTrackWithoutStream) {
CreatePeerConnectionWithoutDtls();
- rtc::scoped_refptr<AudioTrackInterface> audio_track(
+ scoped_refptr<AudioTrackInterface> audio_track(
CreateAudioTrack("audio_track"));
- rtc::scoped_refptr<VideoTrackInterface> video_track(
+ scoped_refptr<VideoTrackInterface> video_track(
CreateVideoTrack("video_track"));
auto audio_sender =
pc_->AddTrack(audio_track, std::vector<std::string>()).MoveValue();
@@ -1651,9 +1645,9 @@
// the PeerConnection to a peer.
TEST_P(PeerConnectionInterfaceTest, AddTrackBeforeConnecting) {
CreatePeerConnection();
- rtc::scoped_refptr<AudioTrackInterface> audio_track(
+ scoped_refptr<AudioTrackInterface> audio_track(
CreateAudioTrack("audio_track"));
- rtc::scoped_refptr<VideoTrackInterface> video_track(
+ scoped_refptr<VideoTrackInterface> video_track(
CreateVideoTrack("video_track"));
auto audio_sender = pc_->AddTrack(audio_track, std::vector<std::string>());
auto video_sender = pc_->AddTrack(video_track, std::vector<std::string>());
@@ -1662,9 +1656,9 @@
TEST_P(PeerConnectionInterfaceTest, AttachmentIdIsSetOnAddTrack) {
CreatePeerConnection();
- rtc::scoped_refptr<AudioTrackInterface> audio_track(
+ scoped_refptr<AudioTrackInterface> audio_track(
CreateAudioTrack("audio_track"));
- rtc::scoped_refptr<VideoTrackInterface> video_track(
+ scoped_refptr<VideoTrackInterface> video_track(
CreateVideoTrack("video_track"));
auto audio_sender = pc_->AddTrack(audio_track, std::vector<std::string>());
ASSERT_TRUE(audio_sender.ok());
@@ -1848,7 +1842,7 @@
MediaStreamInterface* stream = pc_->local_streams()->at(0);
// Add video track to the audio-only stream.
- rtc::scoped_refptr<VideoTrackInterface> video_track(
+ scoped_refptr<VideoTrackInterface> video_track(
CreateVideoTrack("video_label"));
stream->AddTrack(video_track);
@@ -1903,7 +1897,7 @@
InitiateCall();
ASSERT_LT(0u, pc_->GetSenders().size());
ASSERT_LT(0u, pc_->GetReceivers().size());
- rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio =
+ scoped_refptr<MediaStreamTrackInterface> remote_audio =
pc_->GetReceivers()[0]->track();
EXPECT_TRUE(DoGetStats(remote_audio.get()));
@@ -1929,7 +1923,7 @@
// Test that we don't get statistics for an invalid track.
TEST_P(PeerConnectionInterfaceTest, GetStatsForInvalidTrack) {
InitiateCall();
- rtc::scoped_refptr<AudioTrackInterface> unknown_audio_track(
+ scoped_refptr<AudioTrackInterface> unknown_audio_track(
pc_factory_->CreateAudioTrack("unknown track", nullptr));
EXPECT_FALSE(DoGetStats(unknown_audio_track.get()));
}
@@ -2477,8 +2471,7 @@
CreateAnswerAsLocalDescription();
ASSERT_EQ(1u, pc_->local_streams()->count());
- rtc::scoped_refptr<MediaStreamInterface> local_stream(
- pc_->local_streams()->at(0));
+ scoped_refptr<MediaStreamInterface> local_stream(pc_->local_streams()->at(0));
pc_->Close();
@@ -2526,7 +2519,7 @@
CreatePeerConnection(config);
CreateAndSetRemoteOffer(GetSdpStringWithStream1());
- rtc::scoped_refptr<StreamCollection> reference(CreateStreamCollection(1, 1));
+ scoped_refptr<StreamCollection> reference(CreateStreamCollection(1, 1));
EXPECT_TRUE(
CompareStreamCollections(observer_.remote_streams(), reference.get()));
MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
@@ -2536,7 +2529,7 @@
// MediaStream.
CreateAndSetRemoteOffer(GetSdpStringWithStream1And2());
- rtc::scoped_refptr<StreamCollection> reference2(CreateStreamCollection(2, 1));
+ scoped_refptr<StreamCollection> reference2(CreateStreamCollection(2, 1));
EXPECT_TRUE(
CompareStreamCollections(observer_.remote_streams(), reference2.get()));
}
@@ -2561,10 +2554,10 @@
EXPECT_TRUE(DoSetRemoteDescription(std::move(desc_ms1_two_tracks)));
EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
reference_collection_.get()));
- rtc::scoped_refptr<AudioTrackInterface> audio_track2 =
+ scoped_refptr<AudioTrackInterface> audio_track2 =
observer_.remote_streams()->at(0)->GetAudioTracks()[1];
EXPECT_EQ(MediaStreamTrackInterface::kLive, audio_track2->state());
- rtc::scoped_refptr<VideoTrackInterface> video_track2 =
+ scoped_refptr<VideoTrackInterface> video_track2 =
observer_.remote_streams()->at(0)->GetVideoTracks()[1];
EXPECT_EQ(MediaStreamTrackInterface::kLive, video_track2->state());
@@ -2603,10 +2596,10 @@
auto video_receiver = GetFirstReceiverOfType(webrtc::MediaType::VIDEO);
ASSERT_TRUE(video_receiver);
- rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio =
+ scoped_refptr<MediaStreamTrackInterface> remote_audio =
audio_receiver->track();
EXPECT_EQ(MediaStreamTrackInterface::kLive, remote_audio->state());
- rtc::scoped_refptr<MediaStreamTrackInterface> remote_video =
+ scoped_refptr<MediaStreamTrackInterface> remote_video =
video_receiver->track();
EXPECT_EQ(MediaStreamTrackInterface::kLive, remote_video->state());
@@ -2797,7 +2790,7 @@
RTCConfiguration config;
CreatePeerConnection(config);
CreateAndSetRemoteOffer(GetSdpStringWithStream1());
- rtc::scoped_refptr<StreamCollection> reference(CreateStreamCollection(1, 1));
+ scoped_refptr<StreamCollection> reference(CreateStreamCollection(1, 1));
EXPECT_TRUE(
CompareStreamCollections(observer_.remote_streams(), reference.get()));
@@ -2872,7 +2865,7 @@
CreatePeerConnection(config);
// Create an offer with 1 stream with 2 tracks of each type.
- rtc::scoped_refptr<StreamCollection> stream_collection =
+ scoped_refptr<StreamCollection> stream_collection =
CreateStreamCollection(1, 2);
pc_->AddStream(stream_collection->at(0));
std::unique_ptr<SessionDescriptionInterface> offer;
@@ -2909,7 +2902,7 @@
RTCConfiguration config;
CreatePeerConnection(config);
- rtc::scoped_refptr<StreamCollection> stream_collection =
+ scoped_refptr<StreamCollection> stream_collection =
CreateStreamCollection(1, 2);
// Add a stream to create the offer, but remove it afterwards.
pc_->AddStream(stream_collection->at(0));
@@ -2988,7 +2981,7 @@
RTCConfiguration config;
CreatePeerConnection(config);
- rtc::scoped_refptr<StreamCollection> stream_collection =
+ scoped_refptr<StreamCollection> stream_collection =
CreateStreamCollection(2, 1);
pc_->AddStream(stream_collection->at(0));
std::unique_ptr<SessionDescriptionInterface> offer;
@@ -3001,7 +2994,7 @@
EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0], kStreams[0]));
// Add a new MediaStream but with the same tracks as in the first stream.
- rtc::scoped_refptr<MediaStreamInterface> stream_1(
+ scoped_refptr<MediaStreamInterface> stream_1(
MediaStream::Create(kStreams[1]));
stream_1->AddTrack(stream_collection->at(0)->GetVideoTracks()[0]);
stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0]);
@@ -3616,12 +3609,12 @@
TEST_F(PeerConnectionInterfaceTestPlanB,
MediaStreamAddTrackRemoveTrackRenegotiate) {
CreatePeerConnectionWithoutDtls();
- rtc::scoped_refptr<MediaStreamInterface> stream(
+ scoped_refptr<MediaStreamInterface> stream(
pc_factory_->CreateLocalMediaStream(kStreamId1));
pc_->AddStream(stream.get());
- rtc::scoped_refptr<AudioTrackInterface> audio_track(
+ scoped_refptr<AudioTrackInterface> audio_track(
CreateAudioTrack("audio_track"));
- rtc::scoped_refptr<VideoTrackInterface> video_track(
+ scoped_refptr<VideoTrackInterface> video_track(
CreateVideoTrack("video_track"));
stream->AddTrack(audio_track);
EXPECT_THAT(WaitUntil([&] { return observer_.renegotiation_needed_; },
@@ -3706,11 +3699,11 @@
CreatePeerConnection();
AddVideoTrack("video_label");
- std::vector<rtc::scoped_refptr<RtpSenderInterface>> rtp_senders =
+ std::vector<scoped_refptr<RtpSenderInterface>> rtp_senders =
pc_->GetSenders();
ASSERT_EQ(rtp_senders.size(), 1u);
ASSERT_EQ(rtp_senders[0]->media_type(), webrtc::MediaType::VIDEO);
- rtc::scoped_refptr<RtpSenderInterface> video_rtp_sender = rtp_senders[0];
+ scoped_refptr<RtpSenderInterface> video_rtp_sender = rtp_senders[0];
RtpParameters parameters = video_rtp_sender->GetParameters();
ASSERT_NE(parameters.degradation_preference,
DegradationPreference::MAINTAIN_RESOLUTION);
@@ -3746,7 +3739,7 @@
return result.value()->GetConfiguration().media_config;
}
- rtc::scoped_refptr<PeerConnectionFactoryForTest> pcf_;
+ scoped_refptr<PeerConnectionFactoryForTest> pcf_;
MockPeerConnectionObserver observer_;
};
diff --git a/pc/peer_connection_internal.h b/pc/peer_connection_internal.h
index 11bdb07..daa0649 100644
--- a/pc/peer_connection_internal.h
+++ b/pc/peer_connection_internal.h
@@ -119,11 +119,11 @@
// Internal implementation for AddTransceiver family of methods. If
// `fire_callback` is set, fires OnRenegotiationNeeded callback if successful.
- virtual RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
- AddTransceiver(webrtc::MediaType media_type,
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
- const RtpTransceiverInit& init,
- bool fire_callback = true) = 0;
+ virtual RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+ webrtc::MediaType media_type,
+ scoped_refptr<MediaStreamTrackInterface> track,
+ const RtpTransceiverInit& init,
+ bool fire_callback = true) = 0;
// Asynchronously calls SctpTransport::Start() on the network thread for
// `sctp_mid()` if set. Called as part of setting the local description.
virtual RTCError StartSctpTransport(const SctpOptions& options) = 0;
@@ -172,7 +172,7 @@
virtual bool initial_offerer() const = 0;
virtual std::vector<
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
+ scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
GetTransceiversInternal() const = 0;
// Call on the network thread to fetch stats for all the data channels.
@@ -183,7 +183,7 @@
virtual std::optional<std::string> sctp_transport_name() const = 0;
- virtual cricket::CandidateStatsList GetPooledCandidateStats() const = 0;
+ virtual CandidateStatsList GetPooledCandidateStats() const = 0;
// Returns a map from transport name to transport stats for all given
// transport names.
@@ -197,7 +197,7 @@
virtual bool GetLocalCertificate(
const std::string& transport_name,
- rtc::scoped_refptr<RTCCertificate>* certificate) = 0;
+ scoped_refptr<RTCCertificate>* certificate) = 0;
virtual std::unique_ptr<SSLCertChain> GetRemoteSSLCertChain(
const std::string& transport_name) = 0;
diff --git a/pc/peer_connection_jsep_unittest.cc b/pc/peer_connection_jsep_unittest.cc
index 577d84d..27aba15 100644
--- a/pc/peer_connection_jsep_unittest.cc
+++ b/pc/peer_connection_jsep_unittest.cc
@@ -60,7 +60,7 @@
namespace webrtc {
-using cricket::MediaContentDescription;
+using webrtc::MediaContentDescription;
using RTCConfiguration = PeerConnectionInterface::RTCConfiguration;
using ::testing::Combine;
using ::testing::ElementsAre;
@@ -98,7 +98,7 @@
}
WrapperPtr CreatePeerConnection(const RTCConfiguration& config) {
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory =
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory =
CreateModularPeerConnectionFactory(
CreatePeerConnectionFactoryDependencies());
auto observer = std::make_unique<MockPeerConnectionObserver>();
diff --git a/pc/peer_connection_media_unittest.cc b/pc/peer_connection_media_unittest.cc
index 7bcf4aa..242984a 100644
--- a/pc/peer_connection_media_unittest.cc
+++ b/pc/peer_connection_media_unittest.cc
@@ -77,7 +77,7 @@
using ::testing::Values;
RtpTransceiver* RtpTransceiverInternal(
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
+ scoped_refptr<RtpTransceiverInterface> transceiver) {
auto transceiver_with_internal = static_cast<
RefCountedObject<RtpTransceiverProxyWithInternal<RtpTransceiver>>*>(
transceiver.get());
@@ -87,34 +87,34 @@
}
MediaSendChannelInterface* SendChannelInternal(
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
+ scoped_refptr<RtpTransceiverInterface> transceiver) {
auto transceiver_internal = RtpTransceiverInternal(transceiver);
return transceiver_internal->channel()->media_send_channel();
}
MediaReceiveChannelInterface* ReceiveChannelInternal(
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
+ scoped_refptr<RtpTransceiverInterface> transceiver) {
auto transceiver_internal = RtpTransceiverInternal(transceiver);
return transceiver_internal->channel()->media_receive_channel();
}
FakeVideoMediaSendChannel* VideoMediaSendChannel(
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
+ scoped_refptr<RtpTransceiverInterface> transceiver) {
return static_cast<FakeVideoMediaSendChannel*>(
SendChannelInternal(transceiver));
}
FakeVideoMediaReceiveChannel* VideoMediaReceiveChannel(
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
+ scoped_refptr<RtpTransceiverInterface> transceiver) {
return static_cast<FakeVideoMediaReceiveChannel*>(
ReceiveChannelInternal(transceiver));
}
FakeVoiceMediaSendChannel* VoiceMediaSendChannel(
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
+ scoped_refptr<RtpTransceiverInterface> transceiver) {
return static_cast<FakeVoiceMediaSendChannel*>(
SendChannelInternal(transceiver));
}
FakeVoiceMediaReceiveChannel* VoiceMediaReceiveChannel(
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
+ scoped_refptr<RtpTransceiverInterface> transceiver) {
return static_cast<FakeVoiceMediaReceiveChannel*>(
ReceiveChannelInternal(transceiver));
}
diff --git a/pc/peer_connection_message_handler.cc b/pc/peer_connection_message_handler.cc
index 24ddc17..a4494f5 100644
--- a/pc/peer_connection_message_handler.cc
+++ b/pc/peer_connection_message_handler.cc
@@ -28,8 +28,8 @@
namespace {
template <typename T>
-rtc::scoped_refptr<T> WrapScoped(T* ptr) {
- return rtc::scoped_refptr<T>(ptr);
+scoped_refptr<T> WrapScoped(T* ptr) {
+ return scoped_refptr<T>(ptr);
}
} // namespace
diff --git a/pc/peer_connection_proxy.h b/pc/peer_connection_proxy.h
index 93f947f..4f809ab 100644
--- a/pc/peer_connection_proxy.h
+++ b/pc/peer_connection_proxy.h
@@ -53,45 +53,42 @@
// an implementation detail.
BEGIN_PROXY_MAP(PeerConnection)
PROXY_PRIMARY_THREAD_DESTRUCTOR()
-PROXY_METHOD0(rtc::scoped_refptr<StreamCollectionInterface>, local_streams)
-PROXY_METHOD0(rtc::scoped_refptr<StreamCollectionInterface>, remote_streams)
+PROXY_METHOD0(scoped_refptr<StreamCollectionInterface>, local_streams)
+PROXY_METHOD0(scoped_refptr<StreamCollectionInterface>, remote_streams)
PROXY_METHOD1(bool, AddStream, MediaStreamInterface*)
PROXY_METHOD1(void, RemoveStream, MediaStreamInterface*)
-PROXY_METHOD2(RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>>,
+PROXY_METHOD2(RTCErrorOr<scoped_refptr<RtpSenderInterface>>,
AddTrack,
- rtc::scoped_refptr<MediaStreamTrackInterface>,
+ scoped_refptr<MediaStreamTrackInterface>,
const std::vector<std::string>&)
-PROXY_METHOD3(RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>>,
+PROXY_METHOD3(RTCErrorOr<scoped_refptr<RtpSenderInterface>>,
AddTrack,
- rtc::scoped_refptr<MediaStreamTrackInterface>,
+ scoped_refptr<MediaStreamTrackInterface>,
const std::vector<std::string>&,
const std::vector<RtpEncodingParameters>&)
-PROXY_METHOD1(RTCError,
- RemoveTrackOrError,
- rtc::scoped_refptr<RtpSenderInterface>)
-PROXY_METHOD1(RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>,
+PROXY_METHOD1(RTCError, RemoveTrackOrError, scoped_refptr<RtpSenderInterface>)
+PROXY_METHOD1(RTCErrorOr<scoped_refptr<RtpTransceiverInterface>>,
AddTransceiver,
- rtc::scoped_refptr<MediaStreamTrackInterface>)
-PROXY_METHOD2(RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>,
+ scoped_refptr<MediaStreamTrackInterface>)
+PROXY_METHOD2(RTCErrorOr<scoped_refptr<RtpTransceiverInterface>>,
AddTransceiver,
- rtc::scoped_refptr<MediaStreamTrackInterface>,
+ scoped_refptr<MediaStreamTrackInterface>,
const RtpTransceiverInit&)
-PROXY_METHOD1(RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>,
+PROXY_METHOD1(RTCErrorOr<scoped_refptr<RtpTransceiverInterface>>,
AddTransceiver,
webrtc::MediaType)
-PROXY_METHOD2(RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>,
+PROXY_METHOD2(RTCErrorOr<scoped_refptr<RtpTransceiverInterface>>,
AddTransceiver,
webrtc::MediaType,
const RtpTransceiverInit&)
-PROXY_METHOD2(rtc::scoped_refptr<RtpSenderInterface>,
+PROXY_METHOD2(scoped_refptr<RtpSenderInterface>,
CreateSender,
const std::string&,
const std::string&)
-PROXY_CONSTMETHOD0(std::vector<rtc::scoped_refptr<RtpSenderInterface>>,
- GetSenders)
-PROXY_CONSTMETHOD0(std::vector<rtc::scoped_refptr<RtpReceiverInterface>>,
+PROXY_CONSTMETHOD0(std::vector<scoped_refptr<RtpSenderInterface>>, GetSenders)
+PROXY_CONSTMETHOD0(std::vector<scoped_refptr<RtpReceiverInterface>>,
GetReceivers)
-PROXY_CONSTMETHOD0(std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>,
+PROXY_CONSTMETHOD0(std::vector<scoped_refptr<RtpTransceiverInterface>>,
GetTransceivers)
PROXY_METHOD3(bool,
GetStats,
@@ -101,14 +98,14 @@
PROXY_METHOD1(void, GetStats, RTCStatsCollectorCallback*)
PROXY_METHOD2(void,
GetStats,
- rtc::scoped_refptr<RtpSenderInterface>,
- rtc::scoped_refptr<RTCStatsCollectorCallback>)
+ scoped_refptr<RtpSenderInterface>,
+ scoped_refptr<RTCStatsCollectorCallback>)
PROXY_METHOD2(void,
GetStats,
- rtc::scoped_refptr<RtpReceiverInterface>,
- rtc::scoped_refptr<RTCStatsCollectorCallback>)
+ scoped_refptr<RtpReceiverInterface>,
+ scoped_refptr<RTCStatsCollectorCallback>)
PROXY_METHOD0(void, ClearStatsCache)
-PROXY_METHOD2(RTCErrorOr<rtc::scoped_refptr<DataChannelInterface>>,
+PROXY_METHOD2(RTCErrorOr<scoped_refptr<DataChannelInterface>>,
CreateDataChannelOrError,
const std::string&,
const DataChannelInit*)
@@ -134,10 +131,10 @@
PROXY_METHOD2(void,
SetLocalDescription,
std::unique_ptr<SessionDescriptionInterface>,
- rtc::scoped_refptr<SetLocalDescriptionObserverInterface>)
+ scoped_refptr<SetLocalDescriptionObserverInterface>)
PROXY_METHOD1(void,
SetLocalDescription,
- rtc::scoped_refptr<SetLocalDescriptionObserverInterface>)
+ scoped_refptr<SetLocalDescriptionObserverInterface>)
PROXY_METHOD2(void,
SetLocalDescription,
SetSessionDescriptionObserver*,
@@ -146,7 +143,7 @@
PROXY_METHOD2(void,
SetRemoteDescription,
std::unique_ptr<SessionDescriptionInterface>,
- rtc::scoped_refptr<SetRemoteDescriptionObserverInterface>)
+ scoped_refptr<SetRemoteDescriptionObserverInterface>)
PROXY_METHOD2(void,
SetRemoteDescription,
SetSessionDescriptionObserver*,
@@ -170,12 +167,12 @@
PROXY_METHOD1(void, SetAudioRecording, bool)
// This method will be invoked on the network thread. See
// PeerConnectionFactory::CreatePeerConnectionOrError for more details.
-PROXY_SECONDARY_METHOD1(rtc::scoped_refptr<DtlsTransportInterface>,
+PROXY_SECONDARY_METHOD1(scoped_refptr<DtlsTransportInterface>,
LookupDtlsTransportByMid,
const std::string&)
// This method will be invoked on the network thread. See
// PeerConnectionFactory::CreatePeerConnectionOrError for more details.
-PROXY_SECONDARY_CONSTMETHOD0(rtc::scoped_refptr<SctpTransportInterface>,
+PROXY_SECONDARY_CONSTMETHOD0(scoped_refptr<SctpTransportInterface>,
GetSctpTransport)
PROXY_METHOD0(SignalingState, signaling_state)
PROXY_METHOD0(IceConnectionState, ice_connection_state)
@@ -183,7 +180,7 @@
PROXY_METHOD0(PeerConnectionState, peer_connection_state)
PROXY_METHOD0(IceGatheringState, ice_gathering_state)
PROXY_METHOD0(std::optional<bool>, can_trickle_ice_candidates)
-PROXY_METHOD1(void, AddAdaptationResource, rtc::scoped_refptr<Resource>)
+PROXY_METHOD1(void, AddAdaptationResource, scoped_refptr<Resource>)
PROXY_METHOD2(bool,
StartRtcEventLog,
std::unique_ptr<RtcEventLogOutput>,
diff --git a/pc/peer_connection_rampup_tests.cc b/pc/peer_connection_rampup_tests.cc
index 8a848b7..17cc3a2 100644
--- a/pc/peer_connection_rampup_tests.cc
+++ b/pc/peer_connection_rampup_tests.cc
@@ -104,8 +104,8 @@
using PeerConnectionWrapper::PeerConnectionWrapper;
PeerConnectionWrapperForRampUpTest(
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory,
- rtc::scoped_refptr<PeerConnectionInterface> pc,
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory,
+ scoped_refptr<PeerConnectionInterface> pc,
std::unique_ptr<MockPeerConnectionObserver> observer)
: PeerConnectionWrapper::PeerConnectionWrapper(pc_factory,
pc,
@@ -121,27 +121,26 @@
return success;
}
- rtc::scoped_refptr<VideoTrackInterface> CreateLocalVideoTrack(
+ scoped_refptr<VideoTrackInterface> CreateLocalVideoTrack(
FrameGeneratorCapturerVideoTrackSource::Config config,
Clock* clock) {
video_track_sources_.emplace_back(
- rtc::make_ref_counted<FrameGeneratorCapturerVideoTrackSource>(
+ make_ref_counted<FrameGeneratorCapturerVideoTrackSource>(
config, clock, /*is_screencast=*/false));
video_track_sources_.back()->Start();
- return rtc::scoped_refptr<VideoTrackInterface>(
- pc_factory()->CreateVideoTrack(video_track_sources_.back(),
- CreateRandomUuid()));
+ return scoped_refptr<VideoTrackInterface>(pc_factory()->CreateVideoTrack(
+ video_track_sources_.back(), CreateRandomUuid()));
}
- rtc::scoped_refptr<AudioTrackInterface> CreateLocalAudioTrack(
+ scoped_refptr<AudioTrackInterface> CreateLocalAudioTrack(
const AudioOptions options) {
- rtc::scoped_refptr<AudioSourceInterface> source =
+ scoped_refptr<AudioSourceInterface> source =
pc_factory()->CreateAudioSource(options);
return pc_factory()->CreateAudioTrack(CreateRandomUuid(), source.get());
}
private:
- std::vector<rtc::scoped_refptr<FrameGeneratorCapturerVideoTrackSource>>
+ std::vector<scoped_refptr<FrameGeneratorCapturerVideoTrackSource>>
video_track_sources_;
};
diff --git a/pc/peer_connection_rtp_unittest.cc b/pc/peer_connection_rtp_unittest.cc
index 2371c61..ad39b76 100644
--- a/pc/peer_connection_rtp_unittest.cc
+++ b/pc/peer_connection_rtp_unittest.cc
@@ -138,7 +138,7 @@
protected:
const SdpSemantics sdp_semantics_;
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
private:
// Private so that tests don't accidentally bypass the SdpSemantics
@@ -291,7 +291,7 @@
ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
ASSERT_EQ(callee->observer()->add_track_events_.size(), 2u);
EXPECT_EQ(
- std::vector<rtc::scoped_refptr<RtpReceiverInterface>>{
+ std::vector<scoped_refptr<RtpReceiverInterface>>{
callee->observer()->add_track_events_[0].receiver},
callee->observer()->remove_track_events_);
ASSERT_EQ(1u, callee->observer()->remote_streams()->count());
@@ -360,9 +360,9 @@
callee->pc()->GetTransceivers()[0]->mid());
EXPECT_EQ(video_transceiver->mid(),
callee->pc()->GetTransceivers()[1]->mid());
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> audio_streams =
+ std::vector<scoped_refptr<MediaStreamInterface>> audio_streams =
callee->pc()->GetTransceivers()[0]->receiver()->streams();
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> video_streams =
+ std::vector<scoped_refptr<MediaStreamInterface>> video_streams =
callee->pc()->GetTransceivers()[1]->receiver()->streams();
ASSERT_EQ(0u, audio_streams.size());
ASSERT_EQ(2u, video_streams.size());
@@ -747,11 +747,11 @@
// when the first callback is invoked.
callee->pc()->SetRemoteDescription(
std::move(srd1_sdp),
- rtc::make_ref_counted<OnSuccessObserver<decltype(srd1_callback)>>(
+ make_ref_counted<OnSuccessObserver<decltype(srd1_callback)>>(
srd1_callback));
callee->pc()->SetRemoteDescription(
std::move(srd2_sdp),
- rtc::make_ref_counted<OnSuccessObserver<decltype(srd2_callback)>>(
+ make_ref_counted<OnSuccessObserver<decltype(srd2_callback)>>(
srd2_callback));
EXPECT_THAT(
WaitUntil([&] { return srd1_callback_called; }, ::testing::IsTrue()),
@@ -933,8 +933,8 @@
auto caller = CreatePeerConnection();
auto callee = CreatePeerConnection();
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> observer =
- rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ scoped_refptr<MockSetSessionDescriptionObserver> observer =
+ make_ref_counted<MockSetSessionDescriptionObserver>();
auto offer = caller->CreateOfferAndSetAsLocal();
callee->pc()->SetRemoteDescription(observer.get(), offer.release());
@@ -1013,16 +1013,13 @@
auto caller = CreatePeerConnection();
auto transceiver = caller->AddTransceiver(webrtc::MediaType::AUDIO);
+ EXPECT_EQ(std::vector<scoped_refptr<RtpTransceiverInterface>>{transceiver},
+ caller->pc()->GetTransceivers());
EXPECT_EQ(
- std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>{transceiver},
- caller->pc()->GetTransceivers());
- EXPECT_EQ(
- std::vector<rtc::scoped_refptr<RtpSenderInterface>>{
- transceiver->sender()},
+ std::vector<scoped_refptr<RtpSenderInterface>>{transceiver->sender()},
caller->pc()->GetSenders());
EXPECT_EQ(
- std::vector<rtc::scoped_refptr<RtpReceiverInterface>>{
- transceiver->receiver()},
+ std::vector<scoped_refptr<RtpReceiverInterface>>{transceiver->receiver()},
caller->pc()->GetReceivers());
}
diff --git a/pc/peer_connection_signaling_unittest.cc b/pc/peer_connection_signaling_unittest.cc
index 904d2fd..645d62d 100644
--- a/pc/peer_connection_signaling_unittest.cc
+++ b/pc/peer_connection_signaling_unittest.cc
@@ -132,7 +132,7 @@
#endif
pc_factory_ = CreatePeerConnectionFactory(
Thread::Current(), Thread::Current(), Thread::Current(),
- rtc::scoped_refptr<AudioDeviceModule>(FakeAudioCaptureModule::Create()),
+ scoped_refptr<AudioDeviceModule>(FakeAudioCaptureModule::Create()),
CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
std::make_unique<VideoEncoderFactoryTemplate<
LibvpxVp8EncoderTemplateAdapter, LibvpxVp9EncoderTemplateAdapter,
@@ -199,7 +199,7 @@
std::unique_ptr<VirtualSocketServer> vss_;
AutoSocketServerThread main_;
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
const SdpSemantics sdp_semantics_;
};
@@ -572,9 +572,9 @@
options.offer_to_receive_audio =
RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
- rtc::scoped_refptr<MockCreateSessionDescriptionObserver> observers[100];
+ scoped_refptr<MockCreateSessionDescriptionObserver> observers[100];
for (auto& observer : observers) {
- observer = rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ observer = make_ref_counted<MockCreateSessionDescriptionObserver>();
caller->pc()->CreateOffer(observer.get(), options);
}
@@ -598,7 +598,7 @@
// the WebRtcSessionDescriptionFactory is responsible for it.
TEST_P(PeerConnectionSignalingTest, CloseCreateOfferAndShutdown) {
auto caller = CreatePeerConnection();
- auto observer = rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockCreateSessionDescriptionObserver>();
caller->pc()->Close();
caller->pc()->CreateOffer(observer.get(), RTCOfferAnswerOptions());
caller.reset(nullptr);
@@ -619,7 +619,7 @@
TEST_P(PeerConnectionSignalingTest, ImplicitCreateOfferAndShutdown) {
auto caller = CreatePeerConnection();
- auto observer = rtc::make_ref_counted<FakeSetLocalDescriptionObserver>();
+ auto observer = make_ref_counted<FakeSetLocalDescriptionObserver>();
caller->pc()->SetLocalDescription(observer);
caller.reset(nullptr);
// The new observer gets invoked because it is called immediately.
@@ -640,7 +640,7 @@
TEST_P(PeerConnectionSignalingTest, CloseBeforeImplicitCreateOfferAndShutdown) {
auto caller = CreatePeerConnection();
- auto observer = rtc::make_ref_counted<FakeSetLocalDescriptionObserver>();
+ auto observer = make_ref_counted<FakeSetLocalDescriptionObserver>();
caller->pc()->Close();
caller->pc()->SetLocalDescription(observer);
caller.reset(nullptr);
@@ -662,7 +662,7 @@
TEST_P(PeerConnectionSignalingTest, CloseAfterImplicitCreateOfferAndShutdown) {
auto caller = CreatePeerConnection();
- auto observer = rtc::make_ref_counted<FakeSetLocalDescriptionObserver>();
+ auto observer = make_ref_counted<FakeSetLocalDescriptionObserver>();
caller->pc()->SetLocalDescription(observer);
caller->pc()->Close();
caller.reset(nullptr);
@@ -676,7 +676,7 @@
auto caller = CreatePeerConnection();
auto offer = caller->CreateOffer(RTCOfferAnswerOptions());
- auto observer = rtc::make_ref_counted<FakeSetLocalDescriptionObserver>();
+ auto observer = make_ref_counted<FakeSetLocalDescriptionObserver>();
caller->pc()->SetLocalDescription(std::move(offer), observer);
// The new observer is invoked immediately.
EXPECT_TRUE(observer->called());
@@ -713,8 +713,7 @@
// By not waiting for the observer's callback we can verify that the operation
// executed immediately.
callee->pc()->SetRemoteDescription(
- std::move(offer),
- rtc::make_ref_counted<FakeSetRemoteDescriptionObserver>());
+ std::move(offer), make_ref_counted<FakeSetRemoteDescriptionObserver>());
EXPECT_EQ(2u, callee->pc()->GetReceivers().size());
}
@@ -727,14 +726,13 @@
EXPECT_EQ(0u, callee->pc()->GetReceivers().size());
auto offer_observer =
- rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ make_ref_counted<MockCreateSessionDescriptionObserver>();
// Synchronously invoke CreateOffer() and SetRemoteDescription(). The
// SetRemoteDescription() operation should be chained to be executed
// asynchronously, when CreateOffer() completes.
callee->pc()->CreateOffer(offer_observer.get(), RTCOfferAnswerOptions());
callee->pc()->SetRemoteDescription(
- std::move(offer),
- rtc::make_ref_counted<FakeSetRemoteDescriptionObserver>());
+ std::move(offer), make_ref_counted<FakeSetRemoteDescriptionObserver>());
// CreateOffer() is asynchronous; without message processing this operation
// should not have completed.
EXPECT_FALSE(offer_observer->called());
@@ -1145,7 +1143,7 @@
// waiting for it would not ensure synchronicity.
RTC_DCHECK(!caller->pc()->GetTransceivers()[0]->mid().has_value());
caller->pc()->SetLocalDescription(
- rtc::make_ref_counted<MockSetSessionDescriptionObserver>().get(),
+ make_ref_counted<MockSetSessionDescriptionObserver>().get(),
offer.release());
EXPECT_TRUE(caller->pc()->GetTransceivers()[0]->mid().has_value());
}
@@ -1162,8 +1160,7 @@
// other tests.)
RTC_DCHECK(!caller->pc()->GetTransceivers()[0]->mid().has_value());
caller->pc()->SetLocalDescription(
- std::move(offer),
- rtc::make_ref_counted<FakeSetLocalDescriptionObserver>());
+ std::move(offer), make_ref_counted<FakeSetLocalDescriptionObserver>());
EXPECT_TRUE(caller->pc()->GetTransceivers()[0]->mid().has_value());
}
@@ -1175,14 +1172,13 @@
auto offer = caller->CreateOffer(RTCOfferAnswerOptions());
auto offer_observer =
- rtc::make_ref_counted<ExecuteFunctionOnCreateSessionDescriptionObserver>(
+ make_ref_counted<ExecuteFunctionOnCreateSessionDescriptionObserver>(
[pc = caller->pc()](SessionDescriptionInterface* desc) {
// By not waiting for the observer's callback we can verify that the
// operation executed immediately.
RTC_DCHECK(!pc->GetTransceivers()[0]->mid().has_value());
pc->SetLocalDescription(
- rtc::make_ref_counted<MockSetSessionDescriptionObserver>()
- .get(),
+ make_ref_counted<MockSetSessionDescriptionObserver>().get(),
desc);
EXPECT_TRUE(pc->GetTransceivers()[0]->mid().has_value());
});
@@ -1275,7 +1271,7 @@
caller->AddTransceiver(webrtc::MediaType::AUDIO, RtpTransceiverInit());
EXPECT_TRUE(caller->observer()->has_negotiation_needed_event());
- auto observer = rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockCreateSessionDescriptionObserver>();
caller->pc()->CreateOffer(observer.get(), RTCOfferAnswerOptions());
// For this test to work, the operation has to be pending, i.e. the observer
// has not yet been invoked.
diff --git a/pc/peer_connection_simulcast_unittest.cc b/pc/peer_connection_simulcast_unittest.cc
index aedc80a..7ff413d 100644
--- a/pc/peer_connection_simulcast_unittest.cc
+++ b/pc/peer_connection_simulcast_unittest.cc
@@ -67,7 +67,7 @@
using ::testing::SizeIs;
using ::testing::StartsWith;
-using cricket::MediaContentDescription;
+using webrtc::MediaContentDescription;
using ::webrtc::RidDescription;
using ::webrtc::SimulcastDescription;
using ::webrtc::SimulcastLayer;
@@ -98,7 +98,7 @@
nullptr,
nullptr)) {}
- rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
+ scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
MockPeerConnectionObserver* observer) {
PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = SdpSemantics::kUnifiedPlan;
@@ -135,7 +135,7 @@
EXPECT_TRUE(local->SetRemoteDescription(std::move(answer), &err)) << err;
}
- rtc::scoped_refptr<RtpTransceiverInterface> AddTransceiver(
+ scoped_refptr<RtpTransceiverInterface> AddTransceiver(
PeerConnectionWrapper* pc,
const std::vector<SimulcastLayer>& layers,
webrtc::MediaType media_type = webrtc::MediaType::VIDEO) {
@@ -155,7 +155,7 @@
}
void ValidateTransceiverParameters(
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver,
+ scoped_refptr<RtpTransceiverInterface> transceiver,
const std::vector<SimulcastLayer>& layers) {
auto parameters = transceiver->sender()->GetParameters();
std::vector<SimulcastLayer> result_layers;
@@ -167,7 +167,7 @@
}
private:
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
};
// Validates that RIDs are supported arguments when adding a transceiver.
@@ -496,7 +496,7 @@
for (const SimulcastLayer& layer : layers) {
receive_layers.AddLayer(layer);
}
- cricket::RtpHeaderExtensions extensions;
+ RtpHeaderExtensions extensions;
for (auto extension : mcd_answer->rtp_header_extensions()) {
if (extension.uri != RtpExtension::kRidUri) {
extensions.push_back(extension);
diff --git a/pc/peer_connection_stability_integrationtest.cc b/pc/peer_connection_stability_integrationtest.cc
index 02cd30b..61c6ba0 100644
--- a/pc/peer_connection_stability_integrationtest.cc
+++ b/pc/peer_connection_stability_integrationtest.cc
@@ -72,10 +72,10 @@
private:
// Extract a set of strings characterizing the factory in use.
void ExtractSignatureStrings() {
- rtc::scoped_refptr<AudioDecoderFactory> audio_decoders =
+ scoped_refptr<AudioDecoderFactory> audio_decoders =
CreateBuiltinAudioDecoderFactory();
for (const auto& codec : audio_decoders->GetSupportedDecoders()) {
- rtc::StringBuilder sb;
+ StringBuilder sb;
sb << "Decode audio/";
sb << codec.format.name << "/" << codec.format.clockrate_hz << "/"
<< codec.format.num_channels;
@@ -84,10 +84,10 @@
}
signature_.push_back(sb.Release());
}
- rtc::scoped_refptr<AudioEncoderFactory> audio_encoders =
+ scoped_refptr<AudioEncoderFactory> audio_encoders =
CreateBuiltinAudioEncoderFactory();
for (const auto& codec : audio_encoders->GetSupportedEncoders()) {
- rtc::StringBuilder sb;
+ StringBuilder sb;
sb << "Encode audio/";
sb << codec.format.name << "/" << codec.format.clockrate_hz << "/"
<< codec.format.num_channels;
@@ -99,7 +99,7 @@
std::unique_ptr<VideoDecoderFactory> video_decoders =
CreateBuiltinVideoDecoderFactory();
for (const SdpVideoFormat& format : video_decoders->GetSupportedFormats()) {
- rtc::StringBuilder sb;
+ StringBuilder sb;
sb << "Decode video/";
sb << format.name;
for (const auto& kv : format.parameters) {
@@ -110,7 +110,7 @@
std::unique_ptr<VideoEncoderFactory> video_encoders =
CreateBuiltinVideoEncoderFactory();
for (const auto& format : video_encoders->GetSupportedFormats()) {
- rtc::StringBuilder sb;
+ StringBuilder sb;
sb << "Encode video/";
// We don't use format.ToString because that includes scalability modes,
// which aren't supposed to influence SDP.
@@ -324,7 +324,7 @@
return Id::kGoogleInternal;
}
// If unrecognized, produce a debug printout.
- rtc::StringBuilder sb;
+ StringBuilder sb;
sb << "{\n";
for (std::string str : signature_) {
sb << "\"" << str << "\",\n";
@@ -362,7 +362,7 @@
const auto* media_description = content.media_description();
const auto& codecs = media_description->codecs();
for (const auto& codec : codecs) {
- rtc::StringBuilder str;
+ StringBuilder str;
str << media_section_counter << " " << absl::StrCat(codec);
results.push_back(str.Release());
}
@@ -378,7 +378,7 @@
std::vector<std::string> caller_remote,
std::vector<std::string> callee_local,
std::vector<std::string> callee_remote) {
- rtc::StringBuilder sb;
+ StringBuilder sb;
// TODO: issues.webrtc.org/397895867 - change kChangeThis to the name of
// the value. Requires adding an AbslStringifier to the enum.
sb << "\n{" << ".factory_id = FactorySignature::Id::kChangeThis"
diff --git a/pc/peer_connection_svc_integrationtest.cc b/pc/peer_connection_svc_integrationtest.cc
index 9aa4ea8..de3b035 100644
--- a/pc/peer_connection_svc_integrationtest.cc
+++ b/pc/peer_connection_svc_integrationtest.cc
@@ -42,7 +42,7 @@
: PeerConnectionIntegrationBaseTest(SdpSemantics::kUnifiedPlan) {}
RTCError SetCodecPreferences(
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver,
+ scoped_refptr<RtpTransceiverInterface> transceiver,
absl::string_view codec_name) {
RtpCapabilities capabilities =
caller()->pc_factory()->GetRtpReceiverCapabilities(
diff --git a/pc/peer_connection_wrapper.cc b/pc/peer_connection_wrapper.cc
index 20491fe..4f547c7 100644
--- a/pc/peer_connection_wrapper.cc
+++ b/pc/peer_connection_wrapper.cc
@@ -49,8 +49,8 @@
using RTCOfferAnswerOptions = PeerConnectionInterface::RTCOfferAnswerOptions;
PeerConnectionWrapper::PeerConnectionWrapper(
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory,
- rtc::scoped_refptr<PeerConnectionInterface> pc,
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory,
+ scoped_refptr<PeerConnectionInterface> pc,
std::unique_ptr<MockPeerConnectionObserver> observer)
: pc_factory_(std::move(pc_factory)),
observer_(std::move(observer)),
@@ -156,7 +156,7 @@
std::unique_ptr<SessionDescriptionInterface> PeerConnectionWrapper::CreateSdp(
FunctionView<void(CreateSessionDescriptionObserver*)> fn,
std::string* error_out) {
- auto observer = rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockCreateSessionDescriptionObserver>();
fn(observer.get());
EXPECT_THAT(
WaitUntil([&] { return observer->called(); }, ::testing::IsTrue()),
@@ -180,7 +180,7 @@
bool PeerConnectionWrapper::SetLocalDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
RTCError* error_out) {
- auto observer = rtc::make_ref_counted<FakeSetLocalDescriptionObserver>();
+ auto observer = make_ref_counted<FakeSetLocalDescriptionObserver>();
pc()->SetLocalDescription(std::move(desc), observer);
EXPECT_THAT(
WaitUntil([&] { return observer->called(); }, ::testing::IsTrue()),
@@ -204,7 +204,7 @@
bool PeerConnectionWrapper::SetRemoteDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
RTCError* error_out) {
- auto observer = rtc::make_ref_counted<FakeSetRemoteDescriptionObserver>();
+ auto observer = make_ref_counted<FakeSetRemoteDescriptionObserver>();
pc()->SetRemoteDescription(std::move(desc), observer);
EXPECT_THAT(
WaitUntil([&] { return observer->called(); }, ::testing::IsTrue()),
@@ -218,7 +218,7 @@
bool PeerConnectionWrapper::SetSdp(
FunctionView<void(SetSessionDescriptionObserver*)> fn,
std::string* error_out) {
- auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockSetSessionDescriptionObserver>();
fn(observer.get());
EXPECT_THAT(
WaitUntil([&] { return observer->called(); }, ::testing::IsTrue()),
@@ -276,85 +276,82 @@
return set_remote_answer;
}
-rtc::scoped_refptr<RtpTransceiverInterface>
-PeerConnectionWrapper::AddTransceiver(webrtc::MediaType media_type) {
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> result =
+scoped_refptr<RtpTransceiverInterface> PeerConnectionWrapper::AddTransceiver(
+ webrtc::MediaType media_type) {
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> result =
pc()->AddTransceiver(media_type);
EXPECT_EQ(RTCErrorType::NONE, result.error().type());
return result.MoveValue();
}
-rtc::scoped_refptr<RtpTransceiverInterface>
-PeerConnectionWrapper::AddTransceiver(webrtc::MediaType media_type,
- const RtpTransceiverInit& init) {
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> result =
+scoped_refptr<RtpTransceiverInterface> PeerConnectionWrapper::AddTransceiver(
+ webrtc::MediaType media_type,
+ const RtpTransceiverInit& init) {
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> result =
pc()->AddTransceiver(media_type, init);
EXPECT_EQ(RTCErrorType::NONE, result.error().type());
return result.MoveValue();
}
-rtc::scoped_refptr<RtpTransceiverInterface>
-PeerConnectionWrapper::AddTransceiver(
- rtc::scoped_refptr<MediaStreamTrackInterface> track) {
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> result =
+scoped_refptr<RtpTransceiverInterface> PeerConnectionWrapper::AddTransceiver(
+ scoped_refptr<MediaStreamTrackInterface> track) {
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> result =
pc()->AddTransceiver(track);
EXPECT_EQ(RTCErrorType::NONE, result.error().type());
return result.MoveValue();
}
-rtc::scoped_refptr<RtpTransceiverInterface>
-PeerConnectionWrapper::AddTransceiver(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+scoped_refptr<RtpTransceiverInterface> PeerConnectionWrapper::AddTransceiver(
+ scoped_refptr<MediaStreamTrackInterface> track,
const RtpTransceiverInit& init) {
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> result =
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> result =
pc()->AddTransceiver(track, init);
EXPECT_EQ(RTCErrorType::NONE, result.error().type());
return result.MoveValue();
}
-rtc::scoped_refptr<AudioTrackInterface> PeerConnectionWrapper::CreateAudioTrack(
+scoped_refptr<AudioTrackInterface> PeerConnectionWrapper::CreateAudioTrack(
const std::string& label) {
return pc_factory()->CreateAudioTrack(label, nullptr);
}
-rtc::scoped_refptr<VideoTrackInterface> PeerConnectionWrapper::CreateVideoTrack(
+scoped_refptr<VideoTrackInterface> PeerConnectionWrapper::CreateVideoTrack(
const std::string& label) {
return pc_factory()->CreateVideoTrack(FakeVideoTrackSource::Create(), label);
}
-rtc::scoped_refptr<RtpSenderInterface> PeerConnectionWrapper::AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+scoped_refptr<RtpSenderInterface> PeerConnectionWrapper::AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids) {
- RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> result =
+ RTCErrorOr<scoped_refptr<RtpSenderInterface>> result =
pc()->AddTrack(track, stream_ids);
EXPECT_EQ(RTCErrorType::NONE, result.error().type());
return result.MoveValue();
}
-rtc::scoped_refptr<RtpSenderInterface> PeerConnectionWrapper::AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+scoped_refptr<RtpSenderInterface> PeerConnectionWrapper::AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::vector<RtpEncodingParameters>& init_send_encodings) {
- RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> result =
+ RTCErrorOr<scoped_refptr<RtpSenderInterface>> result =
pc()->AddTrack(track, stream_ids, init_send_encodings);
EXPECT_EQ(RTCErrorType::NONE, result.error().type());
return result.MoveValue();
}
-rtc::scoped_refptr<RtpSenderInterface> PeerConnectionWrapper::AddAudioTrack(
+scoped_refptr<RtpSenderInterface> PeerConnectionWrapper::AddAudioTrack(
const std::string& track_label,
const std::vector<std::string>& stream_ids) {
return AddTrack(CreateAudioTrack(track_label), stream_ids);
}
-rtc::scoped_refptr<RtpSenderInterface> PeerConnectionWrapper::AddVideoTrack(
+scoped_refptr<RtpSenderInterface> PeerConnectionWrapper::AddVideoTrack(
const std::string& track_label,
const std::vector<std::string>& stream_ids) {
return AddTrack(CreateVideoTrack(track_label), stream_ids);
}
-rtc::scoped_refptr<DataChannelInterface>
-PeerConnectionWrapper::CreateDataChannel(
+scoped_refptr<DataChannelInterface> PeerConnectionWrapper::CreateDataChannel(
const std::string& label,
const std::optional<DataChannelInit>& config) {
const DataChannelInit* config_ptr = config.has_value() ? &(*config) : nullptr;
@@ -381,8 +378,8 @@
return observer()->ice_connected_;
}
-rtc::scoped_refptr<const RTCStatsReport> PeerConnectionWrapper::GetStats() {
- auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>();
+scoped_refptr<const RTCStatsReport> PeerConnectionWrapper::GetStats() {
+ auto callback = make_ref_counted<MockRTCStatsCollectorCallback>();
pc()->GetStats(callback.get());
EXPECT_THAT(
WaitUntil([&] { return callback->called(); }, ::testing::IsTrue()),
diff --git a/pc/peer_connection_wrapper.h b/pc/peer_connection_wrapper.h
index 49b2da7..e9996cb 100644
--- a/pc/peer_connection_wrapper.h
+++ b/pc/peer_connection_wrapper.h
@@ -54,8 +54,8 @@
// PeerConnection and the MockPeerConnectionObserver should be the observer
// that is watching the PeerConnection.
PeerConnectionWrapper(
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory,
- rtc::scoped_refptr<PeerConnectionInterface> pc,
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory,
+ scoped_refptr<PeerConnectionInterface> pc,
std::unique_ptr<MockPeerConnectionObserver> observer);
virtual ~PeerConnectionWrapper();
@@ -131,51 +131,49 @@
// The following are wrappers for the underlying PeerConnection's
// AddTransceiver method. They return the result of calling AddTransceiver
// with the given arguments, DCHECKing if there is an error.
- rtc::scoped_refptr<RtpTransceiverInterface> AddTransceiver(
+ scoped_refptr<RtpTransceiverInterface> AddTransceiver(
webrtc::MediaType media_type);
- rtc::scoped_refptr<RtpTransceiverInterface> AddTransceiver(
+ scoped_refptr<RtpTransceiverInterface> AddTransceiver(
webrtc::MediaType media_type,
const RtpTransceiverInit& init);
- rtc::scoped_refptr<RtpTransceiverInterface> AddTransceiver(
- rtc::scoped_refptr<MediaStreamTrackInterface> track);
- rtc::scoped_refptr<RtpTransceiverInterface> AddTransceiver(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ scoped_refptr<RtpTransceiverInterface> AddTransceiver(
+ scoped_refptr<MediaStreamTrackInterface> track);
+ scoped_refptr<RtpTransceiverInterface> AddTransceiver(
+ scoped_refptr<MediaStreamTrackInterface> track,
const RtpTransceiverInit& init);
// Returns a new dummy audio track with the given label.
- rtc::scoped_refptr<AudioTrackInterface> CreateAudioTrack(
- const std::string& label);
+ scoped_refptr<AudioTrackInterface> CreateAudioTrack(const std::string& label);
// Returns a new dummy video track with the given label.
- rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack(
- const std::string& label);
+ scoped_refptr<VideoTrackInterface> CreateVideoTrack(const std::string& label);
// Wrapper for the underlying PeerConnection's AddTrack method. DCHECKs if
// AddTrack fails.
- rtc::scoped_refptr<RtpSenderInterface> AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ scoped_refptr<RtpSenderInterface> AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids = {});
- rtc::scoped_refptr<RtpSenderInterface> AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ scoped_refptr<RtpSenderInterface> AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::vector<RtpEncodingParameters>& init_send_encodings);
// Calls the underlying PeerConnection's AddTrack method with an audio media
// stream track not bound to any source.
- rtc::scoped_refptr<RtpSenderInterface> AddAudioTrack(
+ scoped_refptr<RtpSenderInterface> AddAudioTrack(
const std::string& track_label,
const std::vector<std::string>& stream_ids = {});
// Calls the underlying PeerConnection's AddTrack method with a video media
// stream track fed by a FakeVideoTrackSource.
- rtc::scoped_refptr<RtpSenderInterface> AddVideoTrack(
+ scoped_refptr<RtpSenderInterface> AddVideoTrack(
const std::string& track_label,
const std::vector<std::string>& stream_ids = {});
// Calls the underlying PeerConnection's CreateDataChannel method with default
// initialization parameters.
- rtc::scoped_refptr<DataChannelInterface> CreateDataChannel(
+ scoped_refptr<DataChannelInterface> CreateDataChannel(
const std::string& label,
const std::optional<DataChannelInit>& config = std::nullopt);
@@ -190,7 +188,7 @@
// Calls GetStats() on the underlying PeerConnection and returns the resulting
// report. If GetStats() fails, this method returns null and fails the test.
- rtc::scoped_refptr<const RTCStatsReport> GetStats();
+ scoped_refptr<const RTCStatsReport> GetStats();
private:
std::unique_ptr<SessionDescriptionInterface> CreateSdp(
@@ -199,9 +197,9 @@
bool SetSdp(FunctionView<void(SetSessionDescriptionObserver*)> fn,
std::string* error_out);
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
std::unique_ptr<MockPeerConnectionObserver> observer_;
- rtc::scoped_refptr<PeerConnectionInterface> pc_;
+ scoped_refptr<PeerConnectionInterface> pc_;
};
} // namespace webrtc
diff --git a/pc/proxy.h b/pc/proxy.h
index 60ef713..fbc6634 100644
--- a/pc/proxy.h
+++ b/pc/proxy.h
@@ -206,27 +206,27 @@
constexpr char class_name##ProxyWithInternal<INTERNAL_CLASS>::proxy_name_[];
// clang-format on
-#define PRIMARY_PROXY_MAP_BOILERPLATE(class_name) \
- protected: \
- class_name##ProxyWithInternal(rtc::Thread* primary_thread, \
- rtc::scoped_refptr<INTERNAL_CLASS> c) \
- : primary_thread_(primary_thread), c_(std::move(c)) {} \
- \
- private: \
- mutable rtc::Thread* primary_thread_;
+#define PRIMARY_PROXY_MAP_BOILERPLATE(class_name) \
+ protected: \
+ class_name##ProxyWithInternal(Thread* primary_thread, \
+ scoped_refptr<INTERNAL_CLASS> c) \
+ : primary_thread_(primary_thread), c_(std::move(c)) {} \
+ \
+ private: \
+ mutable Thread* primary_thread_;
-#define SECONDARY_PROXY_MAP_BOILERPLATE(class_name) \
- protected: \
- class_name##ProxyWithInternal(rtc::Thread* primary_thread, \
- rtc::Thread* secondary_thread, \
- rtc::scoped_refptr<INTERNAL_CLASS> c) \
- : primary_thread_(primary_thread), \
- secondary_thread_(secondary_thread), \
- c_(std::move(c)) {} \
- \
- private: \
- mutable rtc::Thread* primary_thread_; \
- mutable rtc::Thread* secondary_thread_;
+#define SECONDARY_PROXY_MAP_BOILERPLATE(class_name) \
+ protected: \
+ class_name##ProxyWithInternal(Thread* primary_thread, \
+ Thread* secondary_thread, \
+ scoped_refptr<INTERNAL_CLASS> c) \
+ : primary_thread_(primary_thread), \
+ secondary_thread_(secondary_thread), \
+ c_(std::move(c)) {} \
+ \
+ private: \
+ mutable Thread* primary_thread_; \
+ mutable Thread* secondary_thread_;
// Note that the destructor is protected so that the proxy can only be
// destroyed via RefCountInterface.
@@ -248,7 +248,7 @@
void DestroyInternal() { \
c_ = nullptr; \
} \
- rtc::scoped_refptr<INTERNAL_CLASS> c_;
+ scoped_refptr<INTERNAL_CLASS> c_;
// Note: This doesn't use a unique_ptr, because it intends to handle a corner
// case where an object's deletion triggers a callback that calls back into
@@ -280,35 +280,35 @@
PRIMARY_PROXY_MAP_BOILERPLATE(class_name) \
REFCOUNTED_PROXY_MAP_BOILERPLATE(class_name) \
public: \
- static rtc::scoped_refptr<class_name##ProxyWithInternal> Create( \
- rtc::Thread* primary_thread, rtc::scoped_refptr<INTERNAL_CLASS> c) { \
- return rtc::make_ref_counted<class_name##ProxyWithInternal>( \
- primary_thread, std::move(c)); \
+ static scoped_refptr<class_name##ProxyWithInternal> Create( \
+ Thread* primary_thread, scoped_refptr<INTERNAL_CLASS> c) { \
+ return make_ref_counted<class_name##ProxyWithInternal>(primary_thread, \
+ std::move(c)); \
}
-#define BEGIN_PROXY_MAP(class_name) \
- PROXY_MAP_BOILERPLATE(class_name) \
- SECONDARY_PROXY_MAP_BOILERPLATE(class_name) \
- REFCOUNTED_PROXY_MAP_BOILERPLATE(class_name) \
- public: \
- static rtc::scoped_refptr<class_name##ProxyWithInternal> Create( \
- rtc::Thread* primary_thread, rtc::Thread* secondary_thread, \
- rtc::scoped_refptr<INTERNAL_CLASS> c) { \
- return rtc::make_ref_counted<class_name##ProxyWithInternal>( \
- primary_thread, secondary_thread, std::move(c)); \
+#define BEGIN_PROXY_MAP(class_name) \
+ PROXY_MAP_BOILERPLATE(class_name) \
+ SECONDARY_PROXY_MAP_BOILERPLATE(class_name) \
+ REFCOUNTED_PROXY_MAP_BOILERPLATE(class_name) \
+ public: \
+ static scoped_refptr<class_name##ProxyWithInternal> Create( \
+ Thread* primary_thread, Thread* secondary_thread, \
+ scoped_refptr<INTERNAL_CLASS> c) { \
+ return make_ref_counted<class_name##ProxyWithInternal>( \
+ primary_thread, secondary_thread, std::move(c)); \
}
-#define PROXY_PRIMARY_THREAD_DESTRUCTOR() \
- private: \
- rtc::Thread* destructor_thread() const { \
- return primary_thread_; \
- } \
- \
+#define PROXY_PRIMARY_THREAD_DESTRUCTOR() \
+ private: \
+ Thread* destructor_thread() const { \
+ return primary_thread_; \
+ } \
+ \
public: // NOLINTNEXTLINE
#define PROXY_SECONDARY_THREAD_DESTRUCTOR() \
private: \
- rtc::Thread* destructor_thread() const { \
+ Thread* destructor_thread() const { \
return secondary_thread_; \
} \
\
@@ -319,11 +319,11 @@
do { \
} while (0)
#else // if defined(RTC_DISABLE_PROXY_TRACE_EVENTS)
-#define TRACE_BOILERPLATE(method) \
- static constexpr auto class_and_method_name = \
- rtc::MakeCompileTimeString(proxy_name_) \
- .Concat(rtc::MakeCompileTimeString("::")) \
- .Concat(rtc::MakeCompileTimeString(#method)); \
+#define TRACE_BOILERPLATE(method) \
+ static constexpr auto class_and_method_name = \
+ webrtc::MakeCompileTimeString(proxy_name_) \
+ .Concat(webrtc::MakeCompileTimeString("::")) \
+ .Concat(webrtc::MakeCompileTimeString(#method)); \
TRACE_EVENT0("webrtc", class_and_method_name.string)
#endif // if defined(RTC_DISABLE_PROXY_TRACE_EVENTS)
diff --git a/pc/proxy_unittest.cc b/pc/proxy_unittest.cc
index c7bf3b8..a12e581 100644
--- a/pc/proxy_unittest.cc
+++ b/pc/proxy_unittest.cc
@@ -45,9 +45,7 @@
// Implementation of the test interface.
class Fake : public FakeInterface {
public:
- static rtc::scoped_refptr<Fake> Create() {
- return rtc::make_ref_counted<Fake>();
- }
+ static scoped_refptr<Fake> Create() { return make_ref_counted<Fake>(); }
// Used to verify destructor is called on the correct thread.
MOCK_METHOD(void, Destroy, ());
@@ -106,8 +104,8 @@
protected:
std::unique_ptr<Thread> signaling_thread_;
- rtc::scoped_refptr<FakeInterface> fake_signaling_proxy_;
- rtc::scoped_refptr<Fake> fake_;
+ scoped_refptr<FakeInterface> fake_signaling_proxy_;
+ scoped_refptr<Fake> fake_;
};
TEST_F(SignalingProxyTest, SignalingThreadDestructor) {
@@ -196,8 +194,8 @@
protected:
std::unique_ptr<Thread> signaling_thread_;
std::unique_ptr<Thread> worker_thread_;
- rtc::scoped_refptr<FakeInterface> fake_proxy_;
- rtc::scoped_refptr<Fake> fake_;
+ scoped_refptr<FakeInterface> fake_proxy_;
+ scoped_refptr<Fake> fake_;
};
TEST_F(ProxyTest, WorkerThreadDestructor) {
diff --git a/pc/remote_audio_source.cc b/pc/remote_audio_source.cc
index 2e20700..ecebff5 100644
--- a/pc/remote_audio_source.cc
+++ b/pc/remote_audio_source.cc
@@ -53,7 +53,7 @@
}
private:
- const rtc::scoped_refptr<RemoteAudioSource> source_;
+ const scoped_refptr<RemoteAudioSource> source_;
};
RemoteAudioSource::RemoteAudioSource(
@@ -176,7 +176,7 @@
// processed (because the task queue was destroyed shortly after this call),
// but that is fine because the task queue destructor will take care of
// destroying task which will release the reference on RemoteAudioSource.
- rtc::scoped_refptr<RemoteAudioSource> thiz(this);
+ scoped_refptr<RemoteAudioSource> thiz(this);
main_thread_->PostTask([thiz = std::move(thiz)] {
thiz->sinks_.clear();
thiz->SetState(MediaSourceInterface::kEnded);
diff --git a/pc/rtc_stats_collector.cc b/pc/rtc_stats_collector.cc
index d208c76..a2df878 100644
--- a/pc/rtc_stats_collector.cc
+++ b/pc/rtc_stats_collector.cc
@@ -1065,12 +1065,11 @@
} // namespace
-rtc::scoped_refptr<RTCStatsReport>
-RTCStatsCollector::CreateReportFilteredBySelector(
+scoped_refptr<RTCStatsReport> RTCStatsCollector::CreateReportFilteredBySelector(
bool filter_by_sender_selector,
- rtc::scoped_refptr<const RTCStatsReport> report,
- rtc::scoped_refptr<RtpSenderInternal> sender_selector,
- rtc::scoped_refptr<RtpReceiverInternal> receiver_selector) {
+ scoped_refptr<const RTCStatsReport> report,
+ scoped_refptr<RtpSenderInternal> sender_selector,
+ scoped_refptr<RtpReceiverInternal> receiver_selector) {
std::vector<std::string> rtpstream_ids;
if (filter_by_sender_selector) {
// Filter mode: RTCStatsCollector::RequestInfo::kSenderSelector
@@ -1121,20 +1120,20 @@
}
RTCStatsCollector::RequestInfo::RequestInfo(
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback)
+ scoped_refptr<RTCStatsCollectorCallback> callback)
: RequestInfo(FilterMode::kAll, std::move(callback), nullptr, nullptr) {}
RTCStatsCollector::RequestInfo::RequestInfo(
- rtc::scoped_refptr<RtpSenderInternal> selector,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback)
+ scoped_refptr<RtpSenderInternal> selector,
+ scoped_refptr<RTCStatsCollectorCallback> callback)
: RequestInfo(FilterMode::kSenderSelector,
std::move(callback),
std::move(selector),
nullptr) {}
RTCStatsCollector::RequestInfo::RequestInfo(
- rtc::scoped_refptr<RtpReceiverInternal> selector,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback)
+ scoped_refptr<RtpReceiverInternal> selector,
+ scoped_refptr<RTCStatsCollectorCallback> callback)
: RequestInfo(FilterMode::kReceiverSelector,
std::move(callback),
nullptr,
@@ -1142,9 +1141,9 @@
RTCStatsCollector::RequestInfo::RequestInfo(
RTCStatsCollector::RequestInfo::FilterMode filter_mode,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback,
- rtc::scoped_refptr<RtpSenderInternal> sender_selector,
- rtc::scoped_refptr<RtpReceiverInternal> receiver_selector)
+ scoped_refptr<RTCStatsCollectorCallback> callback,
+ scoped_refptr<RtpSenderInternal> sender_selector,
+ scoped_refptr<RtpReceiverInternal> receiver_selector)
: filter_mode_(filter_mode),
callback_(std::move(callback)),
sender_selector_(std::move(sender_selector)),
@@ -1153,11 +1152,11 @@
RTC_DCHECK(!sender_selector_ || !receiver_selector_);
}
-rtc::scoped_refptr<RTCStatsCollector> RTCStatsCollector::Create(
+scoped_refptr<RTCStatsCollector> RTCStatsCollector::Create(
PeerConnectionInternal* pc,
const Environment& env,
int64_t cache_lifetime_us) {
- return rtc::make_ref_counted<RTCStatsCollector>(pc, env, cache_lifetime_us);
+ return make_ref_counted<RTCStatsCollector>(pc, env, cache_lifetime_us);
}
RTCStatsCollector::RTCStatsCollector(PeerConnectionInternal* pc,
@@ -1188,19 +1187,19 @@
}
void RTCStatsCollector::GetStatsReport(
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback) {
+ scoped_refptr<RTCStatsCollectorCallback> callback) {
GetStatsReportInternal(RequestInfo(std::move(callback)));
}
void RTCStatsCollector::GetStatsReport(
- rtc::scoped_refptr<RtpSenderInternal> selector,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback) {
+ scoped_refptr<RtpSenderInternal> selector,
+ scoped_refptr<RTCStatsCollectorCallback> callback) {
GetStatsReportInternal(RequestInfo(std::move(selector), std::move(callback)));
}
void RTCStatsCollector::GetStatsReport(
- rtc::scoped_refptr<RtpReceiverInternal> selector,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback) {
+ scoped_refptr<RtpReceiverInternal> selector,
+ scoped_refptr<RTCStatsCollectorCallback> callback) {
GetStatsReportInternal(RequestInfo(std::move(selector), std::move(callback)));
}
@@ -1218,8 +1217,8 @@
// reentrancy problems.
signaling_thread_->PostTask(
absl::bind_front(&RTCStatsCollector::DeliverCachedReport,
- rtc::scoped_refptr<RTCStatsCollector>(this),
- cached_report_, std::move(requests_)));
+ 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
@@ -1247,7 +1246,7 @@
// ProducePartialResultsOnNetworkThread() has signaled the
// `network_report_event_`.
network_report_event_.Reset();
- rtc::scoped_refptr<RTCStatsCollector> collector(this);
+ scoped_refptr<RTCStatsCollector> collector(this);
network_thread_->PostTask([collector,
sctp_transport_name = pc_->sctp_transport_name(),
timestamp]() mutable {
@@ -1336,7 +1335,7 @@
// Signal that it is now safe to touch `network_report_` on the signaling
// thread, and post a task to merge it into the final results.
network_report_event_.Set();
- rtc::scoped_refptr<RTCStatsCollector> collector(this);
+ scoped_refptr<RTCStatsCollector> collector(this);
signaling_thread_->PostTask(
[collector] { collector->MergeNetworkReport_s(); });
}
@@ -1399,7 +1398,7 @@
}
void RTCStatsCollector::DeliverCachedReport(
- rtc::scoped_refptr<const RTCStatsReport> cached_report,
+ scoped_refptr<const RTCStatsReport> cached_report,
std::vector<RTCStatsCollector::RequestInfo> requests) {
RTC_DCHECK_RUN_ON(signaling_thread_);
RTC_DCHECK(!requests.empty());
@@ -1410,8 +1409,8 @@
request.callback()->OnStatsDelivered(cached_report);
} else {
bool filter_by_sender_selector;
- rtc::scoped_refptr<RtpSenderInternal> sender_selector;
- rtc::scoped_refptr<RtpReceiverInternal> receiver_selector;
+ scoped_refptr<RtpSenderInternal> sender_selector;
+ scoped_refptr<RtpReceiverInternal> receiver_selector;
if (request.filter_mode() == RequestInfo::FilterMode::kSenderSelector) {
filter_by_sender_selector = true;
sender_selector = request.sender_selector();
@@ -1597,7 +1596,7 @@
// to multiple senders which should result in multiple senders referencing
// the same media-source stats. When all media source related metrics are
// moved to the track's source (e.g. input frame rate is moved from
- // cricket::VideoSenderInfo to VideoTrackSourceInterface::Stats and audio
+ // webrtc::VideoSenderInfo to VideoTrackSourceInterface::Stats and audio
// levels are moved to the corresponding audio track/source object), don't
// create separate media source stats objects on a per-attachment basis.
std::unique_ptr<RTCMediaSourceStats> media_source_stats;
@@ -1735,7 +1734,7 @@
// Inbound and remote-outbound.
// The remote-outbound stats are based on RTCP sender reports sent from the
// remote endpoint providing metrics about the remote outbound streams.
- for (const cricket::VoiceReceiverInfo& voice_receiver_info :
+ for (const VoiceReceiverInfo& voice_receiver_info :
stats.track_media_info_map.voice_media_info()->receivers) {
if (!voice_receiver_info.connected())
continue;
@@ -1744,7 +1743,7 @@
*stats.track_media_info_map.voice_media_info(), voice_receiver_info,
transport_id, mid, timestamp, report);
// TODO(hta): This lookup should look for the sender, not the track.
- rtc::scoped_refptr<AudioTrackInterface> audio_track =
+ scoped_refptr<AudioTrackInterface> audio_track =
stats.track_media_info_map.GetAudioTrack(voice_receiver_info);
if (audio_track) {
inbound_audio->track_identifier = audio_track->id();
@@ -1781,14 +1780,14 @@
}
// Outbound.
std::map<std::string, RTCOutboundRtpStreamStats*> audio_outbound_rtps;
- for (const cricket::VoiceSenderInfo& voice_sender_info :
+ for (const VoiceSenderInfo& voice_sender_info :
stats.track_media_info_map.voice_media_info()->senders) {
if (!voice_sender_info.connected())
continue;
auto outbound_audio = CreateOutboundRTPStreamStatsFromVoiceSenderInfo(
transport_id, mid, *stats.track_media_info_map.voice_media_info(),
voice_sender_info, timestamp, report);
- rtc::scoped_refptr<AudioTrackInterface> audio_track =
+ scoped_refptr<AudioTrackInterface> audio_track =
stats.track_media_info_map.GetAudioTrack(voice_sender_info);
if (audio_track) {
int attachment_id =
@@ -1812,7 +1811,7 @@
// providing metrics about our Outbound streams. We take advantage of the fact
// that RTCOutboundRtpStreamStats, RTCCodecStats and RTCTransport have already
// been added to the report.
- for (const cricket::VoiceSenderInfo& voice_sender_info :
+ for (const VoiceSenderInfo& voice_sender_info :
stats.track_media_info_map.voice_media_info()->senders) {
for (const auto& report_block_data : voice_sender_info.report_block_datas) {
report->AddStats(ProduceRemoteInboundRtpStreamStatsFromReportBlockData(
@@ -1838,14 +1837,14 @@
std::string transport_id = RTCTransportStatsIDFromTransportChannel(
*stats.transport_name, ICE_CANDIDATE_COMPONENT_RTP);
// Inbound and remote-outbound.
- for (const cricket::VideoReceiverInfo& video_receiver_info :
+ for (const VideoReceiverInfo& video_receiver_info :
stats.track_media_info_map.video_media_info()->receivers) {
if (!video_receiver_info.connected())
continue;
auto inbound_video = CreateInboundRTPStreamStatsFromVideoReceiverInfo(
transport_id, mid, *stats.track_media_info_map.video_media_info(),
video_receiver_info, timestamp, report);
- rtc::scoped_refptr<VideoTrackInterface> video_track =
+ scoped_refptr<VideoTrackInterface> video_track =
stats.track_media_info_map.GetVideoTrack(video_receiver_info);
if (video_track) {
inbound_video->track_identifier = video_track->id();
@@ -1876,14 +1875,14 @@
}
// Outbound
std::map<std::string, RTCOutboundRtpStreamStats*> video_outbound_rtps;
- for (const cricket::VideoSenderInfo& video_sender_info :
+ for (const VideoSenderInfo& video_sender_info :
stats.track_media_info_map.video_media_info()->senders) {
if (!video_sender_info.connected())
continue;
auto outbound_video = CreateOutboundRTPStreamStatsFromVideoSenderInfo(
transport_id, mid, *stats.track_media_info_map.video_media_info(),
video_sender_info, timestamp, report);
- rtc::scoped_refptr<VideoTrackInterface> video_track =
+ scoped_refptr<VideoTrackInterface> video_track =
stats.track_media_info_map.GetVideoTrack(video_sender_info);
if (video_track) {
int attachment_id =
@@ -1907,7 +1906,7 @@
// providing metrics about our Outbound streams. We take advantage of the fact
// that RTCOutboundRtpStreamStats, RTCCodecStats and RTCTransport have already
// been added to the report.
- for (const cricket::VideoSenderInfo& video_sender_info :
+ for (const VideoSenderInfo& video_sender_info :
stats.track_media_info_map.video_media_info()->senders) {
for (const auto& report_block_data : video_sender_info.report_block_datas) {
report->AddStats(ProduceRemoteInboundRtpStreamStatsFromReportBlockData(
@@ -1932,7 +1931,7 @@
// Get reference to RTCP channel, if it exists.
std::string rtcp_transport_stats_id;
- for (const cricket::TransportChannelStats& channel_stats :
+ for (const TransportChannelStats& channel_stats :
transport_stats.channel_stats) {
if (channel_stats.component == ICE_CANDIDATE_COMPONENT_RTCP) {
rtcp_transport_stats_id = RTCTransportStatsIDFromTransportChannel(
@@ -1959,7 +1958,7 @@
}
// There is one transport stats for each channel.
- for (const cricket::TransportChannelStats& channel_stats :
+ for (const TransportChannelStats& channel_stats :
transport_stats.channel_stats) {
auto channel_transport_stats = std::make_unique<RTCTransportStats>(
RTCTransportStatsIDFromTransportChannel(transport_name,
@@ -1984,7 +1983,7 @@
channel_transport_stats->ice_state =
IceTransportStateToRTCIceTransportState(
channel_stats.ice_transport_stats.ice_state);
- for (const cricket::ConnectionInfo& info :
+ for (const ConnectionInfo& info :
channel_stats.ice_transport_stats.connection_infos) {
if (info.best_connection) {
channel_transport_stats->selected_candidate_pair_id =
@@ -2036,7 +2035,7 @@
{
MutexLock lock(&cached_certificates_mutex_);
// Copy the certificate info from the cache, avoiding expensive
- // rtc::SSLCertChain::GetStats() calls.
+ // webrtc::SSLCertChain::GetStats() calls.
for (const auto& pair : cached_certificates_by_transport_) {
transport_cert_stats.insert(
std::make_pair(pair.first, pair.second.Copy()));
@@ -2048,7 +2047,7 @@
const std::string& transport_name = entry.first;
CertificateStatsPair certificate_stats_pair;
- rtc::scoped_refptr<RTCCertificate> local_certificate;
+ scoped_refptr<RTCCertificate> local_certificate;
if (pc_->GetLocalCertificate(transport_name, &local_certificate)) {
certificate_stats_pair.local =
local_certificate->GetSSLCertificateChain().GetStats();
@@ -2196,15 +2195,14 @@
std::move(video_receive_stats[video_receive_channel]));
}
}
- std::vector<rtc::scoped_refptr<RtpSenderInternal>> senders;
+ std::vector<scoped_refptr<RtpSenderInternal>> senders;
for (const auto& sender : transceiver->senders()) {
- senders.push_back(
- rtc::scoped_refptr<RtpSenderInternal>(sender->internal()));
+ senders.push_back(scoped_refptr<RtpSenderInternal>(sender->internal()));
}
- std::vector<rtc::scoped_refptr<RtpReceiverInternal>> receivers;
+ std::vector<scoped_refptr<RtpReceiverInternal>> receivers;
for (const auto& receiver : transceiver->receivers()) {
receivers.push_back(
- rtc::scoped_refptr<RtpReceiverInternal>(receiver->internal()));
+ scoped_refptr<RtpReceiverInternal>(receiver->internal()));
}
stats.track_media_info_map.Initialize(std::move(voice_media_info),
std::move(video_media_info),
diff --git a/pc/rtc_stats_collector.h b/pc/rtc_stats_collector.h
index 1bf91ec..016afb4 100644
--- a/pc/rtc_stats_collector.h
+++ b/pc/rtc_stats_collector.h
@@ -57,7 +57,7 @@
// reports are cached for `cache_lifetime_` ms.
class RTCStatsCollector : public RefCountInterface {
public:
- static rtc::scoped_refptr<RTCStatsCollector> Create(
+ static scoped_refptr<RTCStatsCollector> Create(
PeerConnectionInternal* pc,
const Environment& env,
int64_t cache_lifetime_us = 50 * kNumMicrosecsPerMillisec);
@@ -69,15 +69,15 @@
// If the optional selector argument is used, stats are filtered according to
// stats selection algorithm before delivery.
// https://w3c.github.io/webrtc-pc/#dfn-stats-selection-algorithm
- void GetStatsReport(rtc::scoped_refptr<RTCStatsCollectorCallback> callback);
+ void GetStatsReport(scoped_refptr<RTCStatsCollectorCallback> callback);
// If `selector` is null the selection algorithm is still applied (interpreted
// as: no RTP streams are sent by selector). The result is empty.
- void GetStatsReport(rtc::scoped_refptr<RtpSenderInternal> selector,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback);
+ void GetStatsReport(scoped_refptr<RtpSenderInternal> selector,
+ scoped_refptr<RTCStatsCollectorCallback> callback);
// If `selector` is null the selection algorithm is still applied (interpreted
// as: no RTP streams are received by selector). The result is empty.
- void GetStatsReport(rtc::scoped_refptr<RtpReceiverInternal> selector,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback);
+ void GetStatsReport(scoped_refptr<RtpReceiverInternal> selector,
+ scoped_refptr<RTCStatsCollectorCallback> callback);
// Clears the cache's reference to the most recent stats report. Subsequently
// calling `GetStatsReport` guarantees fresh stats. This method must be called
// any time the PeerConnection visibly changes as a result of an API call as
@@ -123,40 +123,39 @@
enum class FilterMode { kAll, kSenderSelector, kReceiverSelector };
// Constructs with FilterMode::kAll.
- explicit RequestInfo(
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback);
+ explicit RequestInfo(scoped_refptr<RTCStatsCollectorCallback> callback);
// Constructs with FilterMode::kSenderSelector. The selection algorithm is
// applied even if `selector` is null, resulting in an empty report.
- RequestInfo(rtc::scoped_refptr<RtpSenderInternal> selector,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback);
+ RequestInfo(scoped_refptr<RtpSenderInternal> selector,
+ scoped_refptr<RTCStatsCollectorCallback> callback);
// Constructs with FilterMode::kReceiverSelector. The selection algorithm is
// applied even if `selector` is null, resulting in an empty report.
- RequestInfo(rtc::scoped_refptr<RtpReceiverInternal> selector,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback);
+ RequestInfo(scoped_refptr<RtpReceiverInternal> selector,
+ scoped_refptr<RTCStatsCollectorCallback> callback);
FilterMode filter_mode() const { return filter_mode_; }
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback() const {
+ scoped_refptr<RTCStatsCollectorCallback> callback() const {
return callback_;
}
- rtc::scoped_refptr<RtpSenderInternal> sender_selector() const {
+ scoped_refptr<RtpSenderInternal> sender_selector() const {
RTC_DCHECK(filter_mode_ == FilterMode::kSenderSelector);
return sender_selector_;
}
- rtc::scoped_refptr<RtpReceiverInternal> receiver_selector() const {
+ scoped_refptr<RtpReceiverInternal> receiver_selector() const {
RTC_DCHECK(filter_mode_ == FilterMode::kReceiverSelector);
return receiver_selector_;
}
private:
RequestInfo(FilterMode filter_mode,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback,
- rtc::scoped_refptr<RtpSenderInternal> sender_selector,
- rtc::scoped_refptr<RtpReceiverInternal> receiver_selector);
+ scoped_refptr<RTCStatsCollectorCallback> callback,
+ scoped_refptr<RtpSenderInternal> sender_selector,
+ scoped_refptr<RtpReceiverInternal> receiver_selector);
FilterMode filter_mode_;
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback_;
- rtc::scoped_refptr<RtpSenderInternal> sender_selector_;
- rtc::scoped_refptr<RtpReceiverInternal> receiver_selector_;
+ scoped_refptr<RTCStatsCollectorCallback> callback_;
+ scoped_refptr<RtpSenderInternal> sender_selector_;
+ scoped_refptr<RtpReceiverInternal> receiver_selector_;
};
void GetStatsReportInternal(RequestInfo request);
@@ -169,7 +168,7 @@
// If a BaseChannel is not available (e.g., if signaling has not started),
// then `mid` and `transport_name` will be null.
struct RtpTransceiverStatsInfo {
- rtc::scoped_refptr<RtpTransceiver> transceiver;
+ scoped_refptr<RtpTransceiver> transceiver;
webrtc::MediaType media_type;
std::optional<std::string> mid;
std::optional<std::string> transport_name;
@@ -177,9 +176,8 @@
std::optional<RtpTransceiverDirection> current_direction;
};
- void DeliverCachedReport(
- rtc::scoped_refptr<const RTCStatsReport> cached_report,
- std::vector<RequestInfo> requests);
+ void DeliverCachedReport(scoped_refptr<const RTCStatsReport> cached_report,
+ std::vector<RequestInfo> requests);
// Produces `RTCCertificateStats`.
void ProduceCertificateStats_n(
@@ -243,11 +241,11 @@
// This is a NO-OP if `network_report_` is null.
void MergeNetworkReport_s();
- rtc::scoped_refptr<RTCStatsReport> CreateReportFilteredBySelector(
+ scoped_refptr<RTCStatsReport> CreateReportFilteredBySelector(
bool filter_by_sender_selector,
- rtc::scoped_refptr<const RTCStatsReport> report,
- rtc::scoped_refptr<RtpSenderInternal> sender_selector,
- rtc::scoped_refptr<RtpReceiverInternal> receiver_selector);
+ scoped_refptr<const RTCStatsReport> report,
+ scoped_refptr<RtpSenderInternal> sender_selector,
+ scoped_refptr<RtpReceiverInternal> receiver_selector);
PeerConnectionInternal* const pc_;
const Environment env_;
@@ -261,13 +259,13 @@
// Reports that are produced on the signaling thread or the network thread are
// merged into this report. It is only touched on the signaling thread. Once
// all partial reports are merged this is the result of a request.
- rtc::scoped_refptr<RTCStatsReport> partial_report_;
+ scoped_refptr<RTCStatsReport> partial_report_;
std::vector<RequestInfo> requests_;
// Holds the result of ProducePartialResultsOnNetworkThread(). It is merged
// into `partial_report_` on the signaling thread and then nulled by
// MergeNetworkReport_s(). Thread-safety is ensured by using
// `network_report_event_`.
- rtc::scoped_refptr<RTCStatsReport> network_report_;
+ scoped_refptr<RTCStatsReport> network_report_;
// If set, it is safe to touch the `network_report_` on the signaling thread.
// This is reset before async-invoking ProducePartialResultsOnNetworkThread()
// and set when ProducePartialResultsOnNetworkThread() is complete, after it
@@ -284,8 +282,8 @@
// now get rid of the variable and keep the data scoped within a stats
// collection sequence.
std::vector<RtpTransceiverStatsInfo> transceiver_stats_infos_;
- // This cache avoids having to call rtc::SSLCertChain::GetStats(), which can
- // relatively expensive. ClearCachedStatsReport() needs to be called on
+ // This cache avoids having to call webrtc::SSLCertChain::GetStats(), which
+ // can relatively expensive. ClearCachedStatsReport() needs to be called on
// negotiation to ensure the cache is not obsolete.
Mutex cached_certificates_mutex_;
std::map<std::string, CertificateStatsPair> cached_certificates_by_transport_
@@ -301,7 +299,7 @@
// report is.
int64_t cache_timestamp_us_;
int64_t cache_lifetime_us_;
- rtc::scoped_refptr<const RTCStatsReport> cached_report_;
+ scoped_refptr<const RTCStatsReport> cached_report_;
// Data recorded and maintained by the stats collector during its lifetime.
// Some stats are produced from this record instead of other components.
diff --git a/pc/rtc_stats_collector_unittest.cc b/pc/rtc_stats_collector_unittest.cc
index 70666b8..7ec0991 100644
--- a/pc/rtc_stats_collector_unittest.cc
+++ b/pc/rtc_stats_collector_unittest.cc
@@ -117,7 +117,7 @@
constexpr uint64_t kRemoteOutboundStatsReportsCount = 9u;
struct CertificateInfo {
- rtc::scoped_refptr<RTCCertificate> certificate;
+ scoped_refptr<RTCCertificate> certificate;
std::vector<std::string> ders;
std::vector<std::string> pems;
std::vector<std::string> fingerprints;
@@ -206,15 +206,14 @@
class FakeAudioTrackForStats : public MediaStreamTrack<AudioTrackInterface> {
public:
- static rtc::scoped_refptr<FakeAudioTrackForStats> Create(
+ static scoped_refptr<FakeAudioTrackForStats> Create(
const std::string& id,
MediaStreamTrackInterface::TrackState state,
bool create_fake_audio_processor) {
- auto audio_track_stats = rtc::make_ref_counted<FakeAudioTrackForStats>(id);
+ auto audio_track_stats = make_ref_counted<FakeAudioTrackForStats>(id);
audio_track_stats->set_state(state);
if (create_fake_audio_processor) {
- audio_track_stats->processor_ =
- rtc::make_ref_counted<FakeAudioProcessor>();
+ audio_track_stats->processor_ = make_ref_counted<FakeAudioProcessor>();
}
return audio_track_stats;
}
@@ -229,21 +228,20 @@
void AddSink(AudioTrackSinkInterface* sink) override {}
void RemoveSink(AudioTrackSinkInterface* sink) override {}
bool GetSignalLevel(int* level) override { return false; }
- rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
+ scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
return processor_;
}
private:
- rtc::scoped_refptr<FakeAudioProcessor> processor_;
+ scoped_refptr<FakeAudioProcessor> processor_;
};
class FakeVideoTrackSourceForStats : public VideoTrackSourceInterface {
public:
- static rtc::scoped_refptr<FakeVideoTrackSourceForStats> Create(
- int input_width,
- int input_height) {
- return rtc::make_ref_counted<FakeVideoTrackSourceForStats>(input_width,
- input_height);
+ static scoped_refptr<FakeVideoTrackSourceForStats> Create(int input_width,
+ int input_height) {
+ return make_ref_counted<FakeVideoTrackSourceForStats>(input_width,
+ input_height);
}
FakeVideoTrackSourceForStats(int input_width, int input_height)
@@ -266,16 +264,17 @@
// NotifierInterface (part of MediaSourceInterface)
void RegisterObserver(ObserverInterface* observer) override {}
void UnregisterObserver(ObserverInterface* observer) override {}
- // rtc::VideoSourceInterface<VideoFrame> (part of VideoTrackSourceInterface)
- void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
+ // webrtc::VideoSourceInterface<VideoFrame> (part of
+ // VideoTrackSourceInterface)
+ void AddOrUpdateSink(VideoSinkInterface<VideoFrame>* sink,
const VideoSinkWants& wants) override {}
- void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override {}
+ void RemoveSink(VideoSinkInterface<VideoFrame>* sink) override {}
bool SupportsEncodedOutput() const override { return false; }
void GenerateKeyFrame() override {}
void AddEncodedSink(
- rtc::VideoSinkInterface<RecordableEncodedFrame>* sink) override {}
+ VideoSinkInterface<RecordableEncodedFrame>* sink) override {}
void RemoveEncodedSink(
- rtc::VideoSinkInterface<RecordableEncodedFrame>* sink) override {}
+ VideoSinkInterface<RecordableEncodedFrame>* sink) override {}
private:
int input_width_;
@@ -284,37 +283,37 @@
class FakeVideoTrackForStats : public MediaStreamTrack<VideoTrackInterface> {
public:
- static rtc::scoped_refptr<FakeVideoTrackForStats> Create(
+ static scoped_refptr<FakeVideoTrackForStats> Create(
const std::string& id,
MediaStreamTrackInterface::TrackState state,
- rtc::scoped_refptr<VideoTrackSourceInterface> source) {
+ scoped_refptr<VideoTrackSourceInterface> source) {
auto video_track =
- rtc::make_ref_counted<FakeVideoTrackForStats>(id, std::move(source));
+ make_ref_counted<FakeVideoTrackForStats>(id, std::move(source));
video_track->set_state(state);
return video_track;
}
FakeVideoTrackForStats(const std::string& id,
- rtc::scoped_refptr<VideoTrackSourceInterface> source)
+ scoped_refptr<VideoTrackSourceInterface> source)
: MediaStreamTrack<VideoTrackInterface>(id), source_(source) {}
std::string kind() const override {
return MediaStreamTrackInterface::kVideoKind;
}
- void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
+ void AddOrUpdateSink(VideoSinkInterface<VideoFrame>* sink,
const VideoSinkWants& wants) override {}
- void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override {}
+ void RemoveSink(VideoSinkInterface<VideoFrame>* sink) override {}
VideoTrackSourceInterface* GetSource() const override {
return source_.get();
}
private:
- rtc::scoped_refptr<VideoTrackSourceInterface> source_;
+ scoped_refptr<VideoTrackSourceInterface> source_;
};
-rtc::scoped_refptr<MediaStreamTrackInterface> CreateFakeTrack(
+scoped_refptr<MediaStreamTrackInterface> CreateFakeTrack(
webrtc::MediaType media_type,
const std::string& track_id,
MediaStreamTrackInterface::TrackState track_state,
@@ -328,9 +327,9 @@
}
}
-rtc::scoped_refptr<MockRtpSenderInternal> CreateMockSender(
+scoped_refptr<MockRtpSenderInternal> CreateMockSender(
webrtc::MediaType media_type,
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ scoped_refptr<MediaStreamTrackInterface> track,
uint32_t ssrc,
int attachment_id,
std::vector<std::string> local_stream_ids) {
@@ -339,7 +338,7 @@
media_type == webrtc::MediaType::AUDIO) ||
(track->kind() == MediaStreamTrackInterface::kVideoKind &&
media_type == webrtc::MediaType::VIDEO));
- auto sender = rtc::make_ref_counted<MockRtpSenderInternal>();
+ auto sender = make_ref_counted<MockRtpSenderInternal>();
EXPECT_CALL(*sender, track()).WillRepeatedly(Return(track));
EXPECT_CALL(*sender, ssrc()).WillRepeatedly(Return(ssrc));
EXPECT_CALL(*sender, media_type()).WillRepeatedly(Return(media_type));
@@ -358,18 +357,18 @@
return sender;
}
-rtc::scoped_refptr<MockRtpReceiverInternal> CreateMockReceiver(
- const rtc::scoped_refptr<MediaStreamTrackInterface>& track,
+scoped_refptr<MockRtpReceiverInternal> CreateMockReceiver(
+ const scoped_refptr<MediaStreamTrackInterface>& track,
uint32_t ssrc,
int attachment_id) {
- auto receiver = rtc::make_ref_counted<MockRtpReceiverInternal>();
+ auto receiver = make_ref_counted<MockRtpReceiverInternal>();
EXPECT_CALL(*receiver, track()).WillRepeatedly(Return(track));
EXPECT_CALL(*receiver, ssrc()).WillRepeatedly(Invoke([ssrc]() {
return ssrc;
}));
EXPECT_CALL(*receiver, streams())
.WillRepeatedly(
- Return(std::vector<rtc::scoped_refptr<MediaStreamInterface>>({})));
+ Return(std::vector<scoped_refptr<MediaStreamInterface>>({})));
EXPECT_CALL(*receiver, media_type())
.WillRepeatedly(
@@ -390,7 +389,7 @@
class RTCStatsCollectorWrapper {
public:
explicit RTCStatsCollectorWrapper(
- rtc::scoped_refptr<FakePeerConnectionForStats> pc,
+ scoped_refptr<FakePeerConnectionForStats> pc,
const Environment& env)
: pc_(pc),
stats_collector_(
@@ -398,65 +397,65 @@
env,
50 * kNumMicrosecsPerMillisec)) {}
- rtc::scoped_refptr<RTCStatsCollector> stats_collector() {
+ scoped_refptr<RTCStatsCollector> stats_collector() {
return stats_collector_;
}
- rtc::scoped_refptr<const RTCStatsReport> GetStatsReport() {
- rtc::scoped_refptr<RTCStatsObtainer> callback = RTCStatsObtainer::Create();
+ scoped_refptr<const RTCStatsReport> GetStatsReport() {
+ scoped_refptr<RTCStatsObtainer> callback = RTCStatsObtainer::Create();
stats_collector_->GetStatsReport(callback);
return WaitForReport(callback);
}
- rtc::scoped_refptr<const RTCStatsReport> GetStatsReportWithSenderSelector(
- rtc::scoped_refptr<RtpSenderInternal> selector) {
- rtc::scoped_refptr<RTCStatsObtainer> callback = RTCStatsObtainer::Create();
+ scoped_refptr<const RTCStatsReport> GetStatsReportWithSenderSelector(
+ scoped_refptr<RtpSenderInternal> selector) {
+ scoped_refptr<RTCStatsObtainer> callback = RTCStatsObtainer::Create();
stats_collector_->GetStatsReport(selector, callback);
return WaitForReport(callback);
}
- rtc::scoped_refptr<const RTCStatsReport> GetStatsReportWithReceiverSelector(
- rtc::scoped_refptr<RtpReceiverInternal> selector) {
- rtc::scoped_refptr<RTCStatsObtainer> callback = RTCStatsObtainer::Create();
+ scoped_refptr<const RTCStatsReport> GetStatsReportWithReceiverSelector(
+ scoped_refptr<RtpReceiverInternal> selector) {
+ scoped_refptr<RTCStatsObtainer> callback = RTCStatsObtainer::Create();
stats_collector_->GetStatsReport(selector, callback);
return WaitForReport(callback);
}
- rtc::scoped_refptr<const RTCStatsReport> GetFreshStatsReport() {
+ scoped_refptr<const RTCStatsReport> GetFreshStatsReport() {
stats_collector_->ClearCachedStatsReport();
return GetStatsReport();
}
- rtc::scoped_refptr<MockRtpSenderInternal> SetupLocalTrackAndSender(
+ scoped_refptr<MockRtpSenderInternal> SetupLocalTrackAndSender(
webrtc::MediaType media_type,
const std::string& track_id,
uint32_t ssrc,
bool add_stream,
int attachment_id) {
- rtc::scoped_refptr<MediaStream> local_stream;
+ scoped_refptr<MediaStream> local_stream;
if (add_stream) {
local_stream = MediaStream::Create("LocalStreamId");
pc_->mutable_local_streams()->AddStream(local_stream);
}
- rtc::scoped_refptr<MediaStreamTrackInterface> track;
+ scoped_refptr<MediaStreamTrackInterface> track;
if (media_type == webrtc::MediaType::AUDIO) {
track = CreateFakeTrack(media_type, track_id,
MediaStreamTrackInterface::kLive);
if (add_stream) {
- local_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
+ local_stream->AddTrack(scoped_refptr<AudioTrackInterface>(
static_cast<AudioTrackInterface*>(track.get())));
}
} else {
track = CreateFakeTrack(media_type, track_id,
MediaStreamTrackInterface::kLive);
if (add_stream) {
- local_stream->AddTrack(rtc::scoped_refptr<VideoTrackInterface>(
+ local_stream->AddTrack(scoped_refptr<VideoTrackInterface>(
static_cast<VideoTrackInterface*>(track.get())));
}
}
- rtc::scoped_refptr<MockRtpSenderInternal> sender =
+ scoped_refptr<MockRtpSenderInternal> sender =
CreateMockSender(media_type, track, ssrc, attachment_id, {});
EXPECT_CALL(*sender, Stop());
EXPECT_CALL(*sender, SetMediaChannel(_));
@@ -465,34 +464,32 @@
return sender;
}
- rtc::scoped_refptr<MockRtpReceiverInternal> SetupRemoteTrackAndReceiver(
+ scoped_refptr<MockRtpReceiverInternal> SetupRemoteTrackAndReceiver(
webrtc::MediaType media_type,
const std::string& track_id,
const std::string& stream_id,
uint32_t ssrc) {
- rtc::scoped_refptr<MediaStream> remote_stream =
- MediaStream::Create(stream_id);
+ scoped_refptr<MediaStream> remote_stream = MediaStream::Create(stream_id);
pc_->mutable_remote_streams()->AddStream(remote_stream);
- rtc::scoped_refptr<MediaStreamTrackInterface> track;
+ scoped_refptr<MediaStreamTrackInterface> track;
if (media_type == webrtc::MediaType::AUDIO) {
track = CreateFakeTrack(media_type, track_id,
MediaStreamTrackInterface::kLive);
- remote_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
+ remote_stream->AddTrack(scoped_refptr<AudioTrackInterface>(
static_cast<AudioTrackInterface*>(track.get())));
} else {
track = CreateFakeTrack(media_type, track_id,
MediaStreamTrackInterface::kLive);
- remote_stream->AddTrack(rtc::scoped_refptr<VideoTrackInterface>(
+ remote_stream->AddTrack(scoped_refptr<VideoTrackInterface>(
static_cast<VideoTrackInterface*>(track.get())));
}
- rtc::scoped_refptr<MockRtpReceiverInternal> receiver =
+ scoped_refptr<MockRtpReceiverInternal> receiver =
CreateMockReceiver(track, ssrc, 62);
EXPECT_CALL(*receiver, streams())
- .WillRepeatedly(
- Return(std::vector<rtc::scoped_refptr<MediaStreamInterface>>(
- {remote_stream})));
+ .WillRepeatedly(Return(
+ std::vector<scoped_refptr<MediaStreamInterface>>({remote_stream})));
EXPECT_CALL(*receiver, SetMediaChannel(_)).WillRepeatedly(Return());
pc_->AddReceiver(receiver);
return receiver;
@@ -518,7 +515,7 @@
std::pair<MediaStreamTrackInterface*, VideoReceiverInfo>>
remote_video_track_info_pairs,
std::vector<std::string> local_stream_ids,
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> remote_streams) {
+ std::vector<scoped_refptr<MediaStreamInterface>> remote_streams) {
VoiceMediaInfo voice_media_info;
VideoMediaInfo video_media_info;
@@ -530,9 +527,9 @@
MediaStreamTrackInterface::kAudioKind);
voice_media_info.senders.push_back(voice_sender_info);
- rtc::scoped_refptr<MockRtpSenderInternal> rtp_sender = CreateMockSender(
+ scoped_refptr<MockRtpSenderInternal> rtp_sender = CreateMockSender(
webrtc::MediaType::AUDIO,
- rtc::scoped_refptr<MediaStreamTrackInterface>(local_audio_track),
+ scoped_refptr<MediaStreamTrackInterface>(local_audio_track),
voice_sender_info.local_stats[0].ssrc,
voice_sender_info.local_stats[0].ssrc + 10, local_stream_ids);
EXPECT_CALL(*rtp_sender, SetMediaChannel(_)).WillRepeatedly(Return());
@@ -549,11 +546,10 @@
MediaStreamTrackInterface::kAudioKind);
voice_media_info.receivers.push_back(voice_receiver_info);
- rtc::scoped_refptr<MockRtpReceiverInternal> rtp_receiver =
- CreateMockReceiver(
- rtc::scoped_refptr<MediaStreamTrackInterface>(remote_audio_track),
- voice_receiver_info.local_stats[0].ssrc,
- voice_receiver_info.local_stats[0].ssrc + 10);
+ scoped_refptr<MockRtpReceiverInternal> rtp_receiver = CreateMockReceiver(
+ scoped_refptr<MediaStreamTrackInterface>(remote_audio_track),
+ voice_receiver_info.local_stats[0].ssrc,
+ voice_receiver_info.local_stats[0].ssrc + 10);
EXPECT_CALL(*rtp_receiver, streams())
.WillRepeatedly(Return(remote_streams));
EXPECT_CALL(*rtp_receiver, SetMediaChannel(_)).WillRepeatedly(Return());
@@ -569,9 +565,9 @@
video_media_info.senders.push_back(video_sender_info);
video_media_info.aggregated_senders.push_back(video_sender_info);
- rtc::scoped_refptr<MockRtpSenderInternal> rtp_sender = CreateMockSender(
+ scoped_refptr<MockRtpSenderInternal> rtp_sender = CreateMockSender(
webrtc::MediaType::VIDEO,
- rtc::scoped_refptr<MediaStreamTrackInterface>(local_video_track),
+ scoped_refptr<MediaStreamTrackInterface>(local_video_track),
video_sender_info.local_stats[0].ssrc,
video_sender_info.local_stats[0].ssrc + 10, local_stream_ids);
EXPECT_CALL(*rtp_sender, SetMediaChannel(_)).WillRepeatedly(Return());
@@ -588,11 +584,10 @@
MediaStreamTrackInterface::kVideoKind);
video_media_info.receivers.push_back(video_receiver_info);
- rtc::scoped_refptr<MockRtpReceiverInternal> rtp_receiver =
- CreateMockReceiver(
- rtc::scoped_refptr<MediaStreamTrackInterface>(remote_video_track),
- video_receiver_info.local_stats[0].ssrc,
- video_receiver_info.local_stats[0].ssrc + 10);
+ scoped_refptr<MockRtpReceiverInternal> rtp_receiver = CreateMockReceiver(
+ scoped_refptr<MediaStreamTrackInterface>(remote_video_track),
+ video_receiver_info.local_stats[0].ssrc,
+ video_receiver_info.local_stats[0].ssrc + 10);
EXPECT_CALL(*rtp_receiver, streams())
.WillRepeatedly(Return(remote_streams));
EXPECT_CALL(*rtp_receiver, SetMediaChannel(_)).WillRepeatedly(Return());
@@ -604,8 +599,8 @@
}
private:
- rtc::scoped_refptr<const RTCStatsReport> WaitForReport(
- rtc::scoped_refptr<RTCStatsObtainer> callback) {
+ scoped_refptr<const RTCStatsReport> WaitForReport(
+ scoped_refptr<RTCStatsObtainer> callback) {
EXPECT_THAT(
WaitUntil(
[&] { return callback->report() != nullptr; }, ::testing::IsTrue(),
@@ -623,20 +618,20 @@
return callback->report();
}
- rtc::scoped_refptr<FakePeerConnectionForStats> pc_;
- rtc::scoped_refptr<RTCStatsCollector> stats_collector_;
+ scoped_refptr<FakePeerConnectionForStats> pc_;
+ scoped_refptr<RTCStatsCollector> stats_collector_;
};
class RTCStatsCollectorTest : public ::testing::Test {
public:
RTCStatsCollectorTest()
- : pc_(rtc::make_ref_counted<FakePeerConnectionForStats>()),
+ : pc_(make_ref_counted<FakePeerConnectionForStats>()),
stats_(new RTCStatsCollectorWrapper(pc_, CreateEnvironment())),
data_channel_controller_(
new FakeDataChannelController(pc_->network_thread())) {}
void ExpectReportContainsCertificateInfo(
- const rtc::scoped_refptr<const RTCStatsReport>& report,
+ const scoped_refptr<const RTCStatsReport>& report,
const CertificateInfo& certinfo) {
for (size_t i = 0; i < certinfo.fingerprints.size(); ++i) {
RTCCertificateStats expected_certificate_stats(
@@ -656,7 +651,7 @@
}
const RTCCertificateStats* GetCertificateStatsFromFingerprint(
- const rtc::scoped_refptr<const RTCStatsReport>& report,
+ const scoped_refptr<const RTCStatsReport>& report,
const std::string& fingerprint) {
auto certificates = report->GetStatsOfType<RTCCertificateStats>();
for (const auto* certificate : certificates) {
@@ -668,10 +663,10 @@
}
struct ExampleStatsGraph {
- rtc::scoped_refptr<RtpSenderInternal> sender;
- rtc::scoped_refptr<RtpReceiverInternal> receiver;
+ scoped_refptr<RtpSenderInternal> sender;
+ scoped_refptr<RtpReceiverInternal> receiver;
- rtc::scoped_refptr<const RTCStatsReport> full_report;
+ scoped_refptr<const RTCStatsReport> full_report;
std::string send_codec_id;
std::string recv_codec_id;
std::string outbound_rtp_id;
@@ -879,13 +874,13 @@
protected:
ScopedFakeClock fake_clock_;
AutoThread main_thread_;
- rtc::scoped_refptr<FakePeerConnectionForStats> pc_;
+ scoped_refptr<FakePeerConnectionForStats> pc_;
std::unique_ptr<RTCStatsCollectorWrapper> stats_;
std::unique_ptr<FakeDataChannelController> data_channel_controller_;
};
TEST_F(RTCStatsCollectorTest, SingleCallback) {
- rtc::scoped_refptr<const RTCStatsReport> result;
+ scoped_refptr<const RTCStatsReport> result;
stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&result));
EXPECT_THAT(
WaitUntil(
@@ -895,7 +890,7 @@
}
TEST_F(RTCStatsCollectorTest, MultipleCallbacks) {
- rtc::scoped_refptr<const RTCStatsReport> a, b, c;
+ scoped_refptr<const RTCStatsReport> a, b, c;
stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&a));
stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&b));
stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&c));
@@ -921,22 +916,22 @@
TEST_F(RTCStatsCollectorTest, CachedStatsReports) {
// Caching should ensure `a` and `b` are the same report.
- rtc::scoped_refptr<const RTCStatsReport> a = stats_->GetStatsReport();
- rtc::scoped_refptr<const RTCStatsReport> b = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> a = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> b = stats_->GetStatsReport();
EXPECT_EQ(a.get(), b.get());
// Invalidate cache by clearing it.
stats_->stats_collector()->ClearCachedStatsReport();
- rtc::scoped_refptr<const RTCStatsReport> c = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> c = stats_->GetStatsReport();
EXPECT_NE(b.get(), c.get());
// Invalidate cache by advancing time.
fake_clock_.AdvanceTime(TimeDelta::Millis(51));
- rtc::scoped_refptr<const RTCStatsReport> d = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> d = stats_->GetStatsReport();
EXPECT_TRUE(d);
EXPECT_NE(c.get(), d.get());
}
TEST_F(RTCStatsCollectorTest, MultipleCallbacksWithInvalidatedCacheInBetween) {
- rtc::scoped_refptr<const RTCStatsReport> a, b, c;
+ scoped_refptr<const RTCStatsReport> a, b, c;
stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&a));
stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&b));
// Cache is invalidated after 50 ms.
@@ -965,7 +960,7 @@
TEST_F(RTCStatsCollectorTest, ToJsonProducesParseableJson) {
ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests();
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
std::string json_format = report->ToJson();
Json::CharReaderBuilder builder;
@@ -996,7 +991,7 @@
kTransportName,
remote_certinfo->certificate->GetSSLCertificateChain().Clone());
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
ExpectReportContainsCertificateInfo(report, *local_certinfo);
ExpectReportContainsCertificateInfo(report, *remote_certinfo);
@@ -1033,7 +1028,7 @@
pc_->AddVideoChannel("Mid4", "Transport2", mid4_info);
// This should not crash (https://crbug.com/1361612).
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
auto inbound_rtps = report->GetStatsOfType<RTCInboundRtpStreamStats>();
auto outbound_rtps = report->GetStatsOfType<RTCOutboundRtpStreamStats>();
EXPECT_EQ(inbound_rtps.size(), 4u);
@@ -1147,7 +1142,7 @@
auto video_channels =
pc_->AddVideoChannel("VideoMid", "TransportName", video_media_info);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCCodecStats expected_inbound_audio_codec(
"CITTransportName1_1_minptime=10;useinbandfec=1", report->timestamp());
@@ -1275,7 +1270,7 @@
// There should be no duplicate codecs because all codec references are on the
// same transport.
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
auto codec_stats = report->GetStatsOfType<RTCCodecStats>();
EXPECT_EQ(codec_stats.size(), 2u);
@@ -1328,7 +1323,7 @@
// Despite having the same PT we should see two codec stats because their FMTP
// lines are different.
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
auto codec_stats = report->GetStatsOfType<RTCCodecStats>();
EXPECT_EQ(codec_stats.size(), 2u);
@@ -1397,7 +1392,7 @@
kVideoTransport,
video_remote_certinfo->certificate->GetSSLCertificateChain().Clone());
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
ExpectReportContainsCertificateInfo(report, *audio_local_certinfo);
ExpectReportContainsCertificateInfo(report, *audio_remote_certinfo);
ExpectReportContainsCertificateInfo(report, *video_local_certinfo);
@@ -1422,7 +1417,7 @@
kTransportName,
remote_certinfo->certificate->GetSSLCertificateChain().Clone());
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
ExpectReportContainsCertificateInfo(report, *local_certinfo);
ExpectReportContainsCertificateInfo(report, *remote_certinfo);
}
@@ -1445,8 +1440,7 @@
ASSERT_EQ(initial_local_certinfo->fingerprints.size(), 2u);
ASSERT_EQ(initial_remote_certinfo->fingerprints.size(), 2u);
- rtc::scoped_refptr<const RTCStatsReport> first_report =
- stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> first_report = stats_->GetStatsReport();
const auto* first_local_cert0 = GetCertificateStatsFromFingerprint(
first_report, initial_local_certinfo->fingerprints[0]);
const auto* first_local_cert1 = GetCertificateStatsFromFingerprint(
@@ -1485,8 +1479,7 @@
// Advance time to ensure a fresh stats report, but don't clear the
// certificate stats cache.
fake_clock.AdvanceTime(TimeDelta::Seconds(1));
- rtc::scoped_refptr<const RTCStatsReport> second_report =
- stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> second_report = stats_->GetStatsReport();
// We expect to see the same certificates as before due to not clearing the
// certificate cache.
const auto* second_local_cert0 =
@@ -1527,8 +1520,7 @@
// Clear the cache, including the cached certificates.
stats_->stats_collector()->ClearCachedStatsReport();
- rtc::scoped_refptr<const RTCStatsReport> third_report =
- stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> third_report = stats_->GetStatsReport();
// Now the old certificates stats should be deleted.
EXPECT_FALSE(third_report->Get(first_local_cert0->id()));
EXPECT_FALSE(third_report->Get(first_local_cert1->id()));
@@ -1550,14 +1542,14 @@
// 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(rtc::make_ref_counted<MockSctpDataChannel>(
+ pc_->AddSctpDataChannel(make_ref_counted<MockSctpDataChannel>(
data_channel_controller_->weak_ptr(), /*id=*/-1,
DataChannelInterface::kConnecting));
- pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
+ pc_->AddSctpDataChannel(make_ref_counted<MockSctpDataChannel>(
data_channel_controller_->weak_ptr(), /*id=*/-1,
DataChannelInterface::kConnecting));
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCDataChannelStats expected_data_channel0("D0", Timestamp::Zero());
// Default values from MockDataChannel.
expected_data_channel0.label = "MockSctpDataChannel";
@@ -1579,7 +1571,7 @@
// 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(rtc::make_ref_counted<MockSctpDataChannel>(
+ pc_->AddSctpDataChannel(make_ref_counted<MockSctpDataChannel>(
data_channel_controller_->weak_ptr(), 0, "MockSctpDataChannel0",
DataChannelInterface::kConnecting, "proto1", 1, 2, 3, 4));
RTCDataChannelStats expected_data_channel0("D0", Timestamp::Zero());
@@ -1592,7 +1584,7 @@
expected_data_channel0.messages_received = 3;
expected_data_channel0.bytes_received = 4;
- pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
+ pc_->AddSctpDataChannel(make_ref_counted<MockSctpDataChannel>(
data_channel_controller_->weak_ptr(), 1, "MockSctpDataChannel1",
DataChannelInterface::kOpen, "proto2", 5, 6, 7, 8));
RTCDataChannelStats expected_data_channel1("D1", Timestamp::Zero());
@@ -1605,7 +1597,7 @@
expected_data_channel1.messages_received = 7;
expected_data_channel1.bytes_received = 8;
- pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
+ pc_->AddSctpDataChannel(make_ref_counted<MockSctpDataChannel>(
data_channel_controller_->weak_ptr(), 2, "MockSctpDataChannel2",
DataChannelInterface::kClosing, "proto1", 9, 10, 11, 12));
RTCDataChannelStats expected_data_channel2("D2", Timestamp::Zero());
@@ -1618,7 +1610,7 @@
expected_data_channel2.messages_received = 11;
expected_data_channel2.bytes_received = 12;
- pc_->AddSctpDataChannel(rtc::make_ref_counted<MockSctpDataChannel>(
+ pc_->AddSctpDataChannel(make_ref_counted<MockSctpDataChannel>(
data_channel_controller_->weak_ptr(), 3, "MockSctpDataChannel3",
DataChannelInterface::kClosed, "proto3", 13, 14, 15, 16));
RTCDataChannelStats expected_data_channel3("D3", Timestamp::Zero());
@@ -1631,7 +1623,7 @@
expected_data_channel3.messages_received = 15;
expected_data_channel3.bytes_received = 16;
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
ASSERT_TRUE(report->Get(expected_data_channel0.id()));
EXPECT_EQ(
@@ -1860,7 +1852,7 @@
pc_->AddVideoChannel("video", "b");
pc_->SetTransportStats("b", b_transport_channel_stats);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
ASSERT_TRUE(report->Get(expected_a_local_host.id()));
EXPECT_EQ(expected_a_local_host, report->Get(expected_a_local_host.id())
@@ -1946,7 +1938,7 @@
pc_->AddVideoChannel("video", kTransportName);
pc_->SetTransportStats(kTransportName, transport_channel_stats);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCIceCandidatePairStats expected_pair(
"CP" + local_candidate->id() + "_" + remote_candidate->id(),
@@ -2081,7 +2073,7 @@
TEST_F(RTCStatsCollectorTest, CollectRTCPeerConnectionStats) {
{
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCPeerConnectionStats expected("P", report->timestamp());
expected.data_channels_opened = 0;
expected.data_channels_closed = 0;
@@ -2090,10 +2082,10 @@
}
FakeDataChannelController controller(pc_->network_thread());
- rtc::scoped_refptr<SctpDataChannel> dummy_channel_a = SctpDataChannel::Create(
+ scoped_refptr<SctpDataChannel> dummy_channel_a = SctpDataChannel::Create(
controller.weak_ptr(), "DummyChannelA", false, InternalDataChannelInit(),
Thread::Current(), Thread::Current());
- rtc::scoped_refptr<SctpDataChannel> dummy_channel_b = SctpDataChannel::Create(
+ scoped_refptr<SctpDataChannel> dummy_channel_b = SctpDataChannel::Create(
controller.weak_ptr(), "DummyChannelB", false, InternalDataChannelInit(),
Thread::Current(), Thread::Current());
@@ -2104,8 +2096,7 @@
dummy_channel_b->internal_id(), DataChannelInterface::DataState::kClosed);
{
- rtc::scoped_refptr<const RTCStatsReport> report =
- stats_->GetFreshStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetFreshStatsReport();
RTCPeerConnectionStats expected("P", report->timestamp());
expected.data_channels_opened = 1;
expected.data_channels_closed = 0;
@@ -2119,8 +2110,7 @@
dummy_channel_b->internal_id(), DataChannelInterface::DataState::kClosed);
{
- rtc::scoped_refptr<const RTCStatsReport> report =
- stats_->GetFreshStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetFreshStatsReport();
RTCPeerConnectionStats expected("P", report->timestamp());
expected.data_channels_opened = 2;
expected.data_channels_closed = 1;
@@ -2134,8 +2124,7 @@
dummy_channel_b->internal_id(), DataChannelInterface::DataState::kOpen);
{
- rtc::scoped_refptr<const RTCStatsReport> report =
- stats_->GetFreshStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetFreshStatsReport();
RTCPeerConnectionStats expected("P", report->timestamp());
expected.data_channels_opened = 3;
expected.data_channels_closed = 1;
@@ -2149,8 +2138,7 @@
dummy_channel_b->internal_id(), DataChannelInterface::DataState::kClosed);
{
- rtc::scoped_refptr<const RTCStatsReport> report =
- stats_->GetFreshStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetFreshStatsReport();
RTCPeerConnectionStats expected("P", report->timestamp());
expected.data_channels_opened = 3;
expected.data_channels_closed = 3;
@@ -2214,7 +2202,7 @@
pc_->GetTransceiversInternal()[0]->internal()->set_current_direction(
RtpTransceiverDirection::kSendRecv);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCInboundRtpStreamStats expected_audio("ITTransportName1A1",
report->timestamp());
@@ -2295,7 +2283,7 @@
// We do not expect a playout id when only sending.
pc_->GetTransceiversInternal()[0]->internal()->set_current_direction(
RtpTransceiverDirection::kSendOnly);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
ASSERT_TRUE(report->Get("ITTransportName1A1"));
auto stats =
report->Get("ITTransportName1A1")->cast_to<RTCInboundRtpStreamStats>();
@@ -2305,8 +2293,7 @@
// We do expect a playout id when receiving.
pc_->GetTransceiversInternal()[0]->internal()->set_current_direction(
RtpTransceiverDirection::kRecvOnly);
- rtc::scoped_refptr<const RTCStatsReport> report =
- stats_->GetFreshStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetFreshStatsReport();
ASSERT_TRUE(report->Get("ITTransportName1A1"));
auto stats =
report->Get("ITTransportName1A1")->cast_to<RTCInboundRtpStreamStats>();
@@ -2385,7 +2372,7 @@
stats_->SetupRemoteTrackAndReceiver(
webrtc::MediaType::VIDEO, "RemoteVideoTrackID", "RemoteStreamId", 1);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCInboundRtpStreamStats expected_video("ITTransportName1V1",
report->timestamp());
@@ -2486,7 +2473,7 @@
stats_->SetupRemoteTrackAndReceiver(
webrtc::MediaType::AUDIO, "RemoteAudioTrackID", "RemoteStreamId", 1);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
auto stats_of_track_type = report->GetStatsOfType<RTCAudioPlayoutStats>();
ASSERT_EQ(1U, stats_of_track_type.size());
@@ -2530,7 +2517,7 @@
stats_->SetupRemoteTrackAndReceiver(
webrtc::MediaType::VIDEO, "RemoteVideoTrackID", "RemoteStreamId", 1);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
auto inbound_rtps = report->GetStatsOfType<RTCInboundRtpStreamStats>();
ASSERT_EQ(inbound_rtps.size(), 1u);
ASSERT_TRUE(inbound_rtps[0]->goog_timing_frame_info.has_value());
@@ -2568,7 +2555,7 @@
"LocalAudioTrackID", 1, true,
/*attachment_id=*/50);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCOutboundRtpStreamStats expected_audio("OTTransportName1A1",
report->timestamp());
@@ -2664,7 +2651,7 @@
"LocalVideoTrackID", 1, true,
/*attachment_id=*/50);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
auto stats_of_my_type = report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_EQ(2U, stats_of_my_type.size());
@@ -2789,7 +2776,7 @@
pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats});
// Get stats without RTCP, an active connection or certificates.
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCTransportStats expected_rtp_transport(
"Ttransport" + absl::StrCat(ICE_CANDIDATE_COMPONENT_RTP),
@@ -2948,7 +2935,7 @@
rtp_transport_channel_stats.ssl_version_bytes = 0x0203;
rtp_transport_channel_stats.dtls_role = SSL_CLIENT;
rtp_transport_channel_stats.ice_transport_stats.ice_role =
- cricket::ICEROLE_CONTROLLING;
+ ICEROLE_CONTROLLING;
rtp_transport_channel_stats.ice_transport_stats.ice_local_username_fragment =
"thelocalufrag";
rtp_transport_channel_stats.ice_transport_stats.ice_state =
@@ -2959,7 +2946,7 @@
pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats});
// Get stats
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCTransportStats expected_rtp_transport(
"Ttransport" + absl::StrCat(ICE_CANDIDATE_COMPONENT_RTP),
@@ -3016,7 +3003,7 @@
"LocalAudioTrackID", 1, false,
/*attachment_id=*/50);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCOutboundRtpStreamStats expected_audio("OTTransportName1A1",
report->timestamp());
@@ -3062,7 +3049,7 @@
"LocalAudioTrackID", kSsrc, false,
kAttachmentId);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCAudioSourceStats expected_audio("SA42", report->timestamp());
expected_audio.track_identifier = "LocalAudioTrackID";
@@ -3101,14 +3088,14 @@
kVideoSourceHeight);
auto video_track = FakeVideoTrackForStats::Create(
"LocalVideoTrackID", MediaStreamTrackInterface::kLive, video_source);
- rtc::scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
+ scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
webrtc::MediaType::VIDEO, video_track, kSsrc, kAttachmentId, {});
EXPECT_CALL(*sender, Stop());
EXPECT_CALL(*sender, SetMediaChannel(_));
EXPECT_CALL(*sender, SetSendCodecs(_));
pc_->AddSender(sender);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCVideoSourceStats expected_video("SV42", report->timestamp());
expected_video.track_identifier = "LocalVideoTrackID";
@@ -3146,14 +3133,14 @@
kVideoSourceHeight);
auto video_track = FakeVideoTrackForStats::Create(
"LocalVideoTrackID", MediaStreamTrackInterface::kLive, video_source);
- rtc::scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
+ scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
webrtc::MediaType::VIDEO, video_track, kNoSsrc, kAttachmentId, {});
EXPECT_CALL(*sender, Stop());
EXPECT_CALL(*sender, SetMediaChannel(_));
EXPECT_CALL(*sender, SetSendCodecs(_));
pc_->AddSender(sender);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
ASSERT_TRUE(report->Get("SV42"));
auto video_stats = report->Get("SV42")->cast_to<RTCVideoSourceStats>();
EXPECT_FALSE(video_stats.frames_per_second.has_value());
@@ -3177,14 +3164,14 @@
auto video_track = FakeVideoTrackForStats::Create(
"LocalVideoTrackID", MediaStreamTrackInterface::kLive,
/*source=*/nullptr);
- rtc::scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
+ scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
webrtc::MediaType::VIDEO, video_track, kSsrc, kAttachmentId, {});
EXPECT_CALL(*sender, Stop());
EXPECT_CALL(*sender, SetMediaChannel(_));
EXPECT_CALL(*sender, SetSendCodecs(_));
pc_->AddSender(sender);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
ASSERT_TRUE(report->Get("SV42"));
auto video_stats = report->Get("SV42")->cast_to<RTCVideoSourceStats>();
EXPECT_FALSE(video_stats.width.has_value());
@@ -3201,14 +3188,14 @@
voice_media_info.senders[0].local_stats.push_back(SsrcSenderInfo());
voice_media_info.senders[0].local_stats[0].ssrc = kSsrc;
pc_->AddVoiceChannel("AudioMid", "TransportName", voice_media_info);
- rtc::scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
+ scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
webrtc::MediaType::AUDIO, /*track=*/nullptr, kSsrc, kAttachmentId, {});
EXPECT_CALL(*sender, Stop());
EXPECT_CALL(*sender, SetMediaChannel(_));
EXPECT_CALL(*sender, SetSendCodecs(_));
pc_->AddSender(sender);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
EXPECT_FALSE(report->Get("SA42"));
}
@@ -3332,7 +3319,7 @@
AddSenderInfoAndMediaChannel("TransportName", report_block_datas,
std::nullopt);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
for (auto ssrc : ssrcs) {
std::string stream_id = "" + std::to_string(ssrc);
RTCRemoteInboundRtpStreamStats expected_remote_inbound_rtp(
@@ -3385,7 +3372,7 @@
AddSenderInfoAndMediaChannel("TransportName", {report_block_data},
std::nullopt);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
std::string remote_inbound_rtp_id = "RI" + MediaTypeCharStr() + "12";
ASSERT_TRUE(report->Get(remote_inbound_rtp_id));
@@ -3417,7 +3404,7 @@
// Advance time, it should be OK to have fresher reports than report blocks.
fake_clock_.AdvanceTime(TimeDelta::Micros(1234));
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
std::string remote_inbound_rtp_id = "RI" + MediaTypeCharStr() + "12";
ASSERT_TRUE(report->Get(remote_inbound_rtp_id));
@@ -3453,7 +3440,7 @@
AddSenderInfoAndMediaChannel("TransportName", {report_block_data}, codec);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
std::string remote_inbound_rtp_id = "RI" + MediaTypeCharStr() + "12";
ASSERT_TRUE(report->Get(remote_inbound_rtp_id));
@@ -3494,7 +3481,7 @@
AddSenderInfoAndMediaChannel("TransportName", {report_block_data},
std::nullopt);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
std::string remote_inbound_rtp_id = "RI" + MediaTypeCharStr() + "12";
ASSERT_TRUE(report->Get(remote_inbound_rtp_id));
@@ -3521,7 +3508,7 @@
EXPECT_FALSE(graph.full_report->Get(graph.remote_outbound_rtp_id));
// Also check that no other remote outbound report is created (in case the
// expected ID is incorrect).
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
ASSERT_NE(report->begin(), report->end())
<< "No reports have been generated.";
for (const auto& stats : *report) {
@@ -3560,30 +3547,30 @@
video_media_info.senders[0].framerate_input = 29.0;
pc_->AddVideoChannel("VideoMid", "TransportName", video_media_info);
- rtc::scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
+ scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
webrtc::MediaType::VIDEO, /*track=*/nullptr, kSsrc, kAttachmentId, {});
EXPECT_CALL(*sender, Stop());
EXPECT_CALL(*sender, SetMediaChannel(_));
EXPECT_CALL(*sender, SetSendCodecs(_));
pc_->AddSender(sender);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
EXPECT_FALSE(report->Get("SV42"));
}
// Test collecting echo return loss stats from the audio processor attached to
// the track, rather than the voice sender info.
TEST_F(RTCStatsCollectorTest, CollectEchoReturnLossFromTrackAudioProcessor) {
- rtc::scoped_refptr<MediaStream> local_stream =
+ scoped_refptr<MediaStream> local_stream =
MediaStream::Create("LocalStreamId");
pc_->mutable_local_streams()->AddStream(local_stream);
// Local audio track
- rtc::scoped_refptr<MediaStreamTrackInterface> local_audio_track =
+ scoped_refptr<MediaStreamTrackInterface> local_audio_track =
CreateFakeTrack(webrtc::MediaType::AUDIO, "LocalAudioTrackID",
MediaStreamTrackInterface::kEnded,
/*create_fake_audio_processor=*/true);
- local_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
+ local_stream->AddTrack(scoped_refptr<AudioTrackInterface>(
static_cast<AudioTrackInterface*>(local_audio_track.get())));
VoiceSenderInfo voice_sender_info_ssrc1;
@@ -3594,7 +3581,7 @@
{std::make_pair(local_audio_track.get(), voice_sender_info_ssrc1)}, {},
{}, {}, {local_stream->id()}, {});
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
RTCAudioSourceStats expected_audio("SA11", report->timestamp());
expected_audio.track_identifier = "LocalAudioTrackID";
@@ -3621,7 +3608,7 @@
// | |
// v v
// codec (send) transport
- rtc::scoped_refptr<const RTCStatsReport> sender_report =
+ scoped_refptr<const RTCStatsReport> sender_report =
stats_->GetStatsReportWithSenderSelector(graph.sender);
EXPECT_TRUE(sender_report);
EXPECT_EQ(sender_report->timestamp(), graph.full_report->timestamp());
@@ -3645,7 +3632,7 @@
// | |
// v v
// transport codec (recv)
- rtc::scoped_refptr<const RTCStatsReport> receiver_report =
+ scoped_refptr<const RTCStatsReport> receiver_report =
stats_->GetStatsReportWithReceiverSelector(graph.receiver);
EXPECT_TRUE(receiver_report);
EXPECT_EQ(receiver_report->size(), 3u);
@@ -3661,7 +3648,7 @@
TEST_F(RTCStatsCollectorTest, GetStatsWithNullSenderSelector) {
ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests();
- rtc::scoped_refptr<const RTCStatsReport> empty_report =
+ scoped_refptr<const RTCStatsReport> empty_report =
stats_->GetStatsReportWithSenderSelector(nullptr);
EXPECT_TRUE(empty_report);
EXPECT_EQ(empty_report->timestamp(), graph.full_report->timestamp());
@@ -3670,7 +3657,7 @@
TEST_F(RTCStatsCollectorTest, GetStatsWithNullReceiverSelector) {
ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests();
- rtc::scoped_refptr<const RTCStatsReport> empty_report =
+ scoped_refptr<const RTCStatsReport> empty_report =
stats_->GetStatsReportWithReceiverSelector(nullptr);
EXPECT_TRUE(empty_report);
EXPECT_EQ(empty_report->timestamp(), graph.full_report->timestamp());
@@ -3680,15 +3667,15 @@
// Before SetLocalDescription() senders don't have an SSRC.
// To simulate this case we create a mock sender with SSRC=0.
TEST_F(RTCStatsCollectorTest, RtpIsMissingWhileSsrcIsZero) {
- rtc::scoped_refptr<MediaStreamTrackInterface> track = CreateFakeTrack(
+ scoped_refptr<MediaStreamTrackInterface> track = CreateFakeTrack(
webrtc::MediaType::AUDIO, "audioTrack", MediaStreamTrackInterface::kLive);
- rtc::scoped_refptr<MockRtpSenderInternal> sender =
+ scoped_refptr<MockRtpSenderInternal> sender =
CreateMockSender(webrtc::MediaType::AUDIO, track, 0, 49, {});
EXPECT_CALL(*sender, Stop());
EXPECT_CALL(*sender, SetSendCodecs(_));
pc_->AddSender(sender);
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
auto outbound_rtps = report->GetStatsOfType<RTCOutboundRtpStreamStats>();
EXPECT_TRUE(outbound_rtps.empty());
@@ -3697,16 +3684,16 @@
// We may also be in a case where the SSRC has been assigned but no
// `voice_sender_info` stats exist yet.
TEST_F(RTCStatsCollectorTest, DoNotCrashIfSsrcIsKnownButInfosAreStillMissing) {
- rtc::scoped_refptr<MediaStreamTrackInterface> track = CreateFakeTrack(
+ scoped_refptr<MediaStreamTrackInterface> track = CreateFakeTrack(
webrtc::MediaType::AUDIO, "audioTrack", MediaStreamTrackInterface::kLive);
- rtc::scoped_refptr<MockRtpSenderInternal> sender =
+ scoped_refptr<MockRtpSenderInternal> sender =
CreateMockSender(webrtc::MediaType::AUDIO, track, 4711, 49, {});
EXPECT_CALL(*sender, Stop());
EXPECT_CALL(*sender, SetSendCodecs(_));
pc_->AddSender(sender);
// We do not generate any matching voice_sender_info stats.
- rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+ scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
auto outbound_rtps = report->GetStatsOfType<RTCOutboundRtpStreamStats>();
EXPECT_TRUE(outbound_rtps.empty());
}
@@ -3717,7 +3704,7 @@
explicit RecursiveCallback(RTCStatsCollectorWrapper* stats) : stats_(stats) {}
void OnStatsDelivered(
- const rtc::scoped_refptr<const RTCStatsReport>& report) override {
+ const scoped_refptr<const RTCStatsReport>& report) override {
stats_->GetStatsReport();
called_ = true;
}
@@ -3732,8 +3719,8 @@
// Test that nothing bad happens if a callback causes GetStatsReport to be
// called again recursively. Regression test for crbug.com/webrtc/8973.
TEST_F(RTCStatsCollectorTest, DoNotCrashWhenGetStatsCalledDuringCallback) {
- auto callback1 = rtc::make_ref_counted<RecursiveCallback>(stats_.get());
- auto callback2 = rtc::make_ref_counted<RecursiveCallback>(stats_.get());
+ auto callback1 = make_ref_counted<RecursiveCallback>(stats_.get());
+ auto callback2 = make_ref_counted<RecursiveCallback>(stats_.get());
stats_->stats_collector()->GetStatsReport(callback1);
stats_->stats_collector()->GetStatsReport(callback2);
EXPECT_THAT(
@@ -3768,13 +3755,13 @@
class FakeRTCStatsCollector : public RTCStatsCollector,
public RTCStatsCollectorCallback {
public:
- static rtc::scoped_refptr<FakeRTCStatsCollector> Create(
+ static scoped_refptr<FakeRTCStatsCollector> Create(
PeerConnectionInternal* pc,
const Environment& env,
int64_t cache_lifetime_us) {
- return rtc::scoped_refptr<FakeRTCStatsCollector>(
- new rtc::RefCountedObject<FakeRTCStatsCollector>(pc, env,
- cache_lifetime_us));
+ return scoped_refptr<FakeRTCStatsCollector>(
+ new RefCountedObject<FakeRTCStatsCollector>(pc, env,
+ cache_lifetime_us));
}
// Since FakeRTCStatsCollector inherits twice from RefCountInterface, once via
@@ -3789,14 +3776,14 @@
// RTCStatsCollectorCallback implementation.
void OnStatsDelivered(
- const rtc::scoped_refptr<const RTCStatsReport>& report) override {
+ const scoped_refptr<const RTCStatsReport>& report) override {
EXPECT_TRUE(signaling_thread_->IsCurrent());
MutexLock lock(&lock_);
delivered_report_ = report;
}
void VerifyThreadUsageAndResultsMerging() {
- GetStatsReport(rtc::scoped_refptr<RTCStatsCollectorCallback>(this));
+ GetStatsReport(scoped_refptr<RTCStatsCollectorCallback>(this));
EXPECT_THAT(
WaitUntil(
[&] { return HasVerifiedResults(); }, ::testing::IsTrue(),
@@ -3865,15 +3852,15 @@
Thread* const network_thread_;
Mutex lock_;
- rtc::scoped_refptr<const RTCStatsReport> delivered_report_;
+ scoped_refptr<const RTCStatsReport> delivered_report_;
int produced_on_signaling_thread_ = 0;
int produced_on_network_thread_ = 0;
};
TEST(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
AutoThread main_thread_;
- auto pc = rtc::make_ref_counted<FakePeerConnectionForStats>();
- rtc::scoped_refptr<FakeRTCStatsCollector> stats_collector(
+ auto pc = make_ref_counted<FakePeerConnectionForStats>();
+ scoped_refptr<FakeRTCStatsCollector> stats_collector(
FakeRTCStatsCollector::Create(pc.get(), CreateEnvironment(),
50 * kNumMicrosecsPerMillisec));
stats_collector->VerifyThreadUsageAndResultsMerging();
diff --git a/pc/rtc_stats_integrationtest.cc b/pc/rtc_stats_integrationtest.cc
index 8889ed0..7562f80 100644
--- a/pc/rtc_stats_integrationtest.cc
+++ b/pc/rtc_stats_integrationtest.cc
@@ -60,10 +60,10 @@
RTC_CHECK(network_thread_->Start());
RTC_CHECK(worker_thread_->Start());
- caller_ = rtc::make_ref_counted<PeerConnectionTestWrapper>(
+ caller_ = make_ref_counted<PeerConnectionTestWrapper>(
"caller", &virtual_socket_server_, network_thread_.get(),
worker_thread_.get());
- callee_ = rtc::make_ref_counted<PeerConnectionTestWrapper>(
+ callee_ = make_ref_counted<PeerConnectionTestWrapper>(
"callee", &virtual_socket_server_, network_thread_.get(),
worker_thread_.get());
}
@@ -96,35 +96,34 @@
callee_->WaitForCallEstablished();
}
- rtc::scoped_refptr<const RTCStatsReport> GetStatsFromCaller() {
+ scoped_refptr<const RTCStatsReport> GetStatsFromCaller() {
return GetStats(caller_->pc());
}
- rtc::scoped_refptr<const RTCStatsReport> GetStatsFromCaller(
- rtc::scoped_refptr<RtpSenderInterface> selector) {
+ scoped_refptr<const RTCStatsReport> GetStatsFromCaller(
+ scoped_refptr<RtpSenderInterface> selector) {
return GetStats(caller_->pc(), selector);
}
- rtc::scoped_refptr<const RTCStatsReport> GetStatsFromCaller(
- rtc::scoped_refptr<RtpReceiverInterface> selector) {
+ scoped_refptr<const RTCStatsReport> GetStatsFromCaller(
+ scoped_refptr<RtpReceiverInterface> selector) {
return GetStats(caller_->pc(), selector);
}
- rtc::scoped_refptr<const RTCStatsReport> GetStatsFromCallee() {
+ scoped_refptr<const RTCStatsReport> GetStatsFromCallee() {
return GetStats(callee_->pc());
}
- rtc::scoped_refptr<const RTCStatsReport> GetStatsFromCallee(
- rtc::scoped_refptr<RtpSenderInterface> selector) {
+ scoped_refptr<const RTCStatsReport> GetStatsFromCallee(
+ scoped_refptr<RtpSenderInterface> selector) {
return GetStats(callee_->pc(), selector);
}
- rtc::scoped_refptr<const RTCStatsReport> GetStatsFromCallee(
- rtc::scoped_refptr<RtpReceiverInterface> selector) {
+ scoped_refptr<const RTCStatsReport> GetStatsFromCallee(
+ scoped_refptr<RtpReceiverInterface> selector) {
return GetStats(callee_->pc(), selector);
}
protected:
- static rtc::scoped_refptr<const RTCStatsReport> GetStats(
+ static scoped_refptr<const RTCStatsReport> GetStats(
PeerConnectionInterface* pc) {
- rtc::scoped_refptr<RTCStatsObtainer> stats_obtainer =
- RTCStatsObtainer::Create();
+ scoped_refptr<RTCStatsObtainer> stats_obtainer = RTCStatsObtainer::Create();
pc->GetStats(stats_obtainer.get());
EXPECT_THAT(
WaitUntil([&] { return stats_obtainer->report() != nullptr; },
@@ -135,11 +134,10 @@
}
template <typename T>
- static rtc::scoped_refptr<const RTCStatsReport> GetStats(
+ static scoped_refptr<const RTCStatsReport> GetStats(
PeerConnectionInterface* pc,
- rtc::scoped_refptr<T> selector) {
- rtc::scoped_refptr<RTCStatsObtainer> stats_obtainer =
- RTCStatsObtainer::Create();
+ scoped_refptr<T> selector) {
+ scoped_refptr<RTCStatsObtainer> stats_obtainer = RTCStatsObtainer::Create();
pc->GetStats(selector, stats_obtainer);
EXPECT_THAT(
WaitUntil([&] { return stats_obtainer->report() != nullptr; },
@@ -154,8 +152,8 @@
VirtualSocketServer virtual_socket_server_;
std::unique_ptr<Thread> network_thread_;
std::unique_ptr<Thread> worker_thread_;
- rtc::scoped_refptr<PeerConnectionTestWrapper> caller_;
- rtc::scoped_refptr<PeerConnectionTestWrapper> callee_;
+ scoped_refptr<PeerConnectionTestWrapper> caller_;
+ scoped_refptr<PeerConnectionTestWrapper> callee_;
};
class RTCStatsVerifier {
@@ -286,7 +284,7 @@
MarkAttributeTested(field, valid_reference);
}
- rtc::scoped_refptr<const RTCStatsReport> report_;
+ scoped_refptr<const RTCStatsReport> report_;
const RTCStats* stats_;
std::set<const char*> untested_attribute_names_;
bool all_tests_successful_;
@@ -1014,21 +1012,21 @@
}
private:
- rtc::scoped_refptr<const RTCStatsReport> report_;
+ scoped_refptr<const RTCStatsReport> report_;
};
#ifdef WEBRTC_HAVE_SCTP
TEST_F(RTCStatsIntegrationTest, GetStatsFromCaller) {
StartCall();
- rtc::scoped_refptr<const RTCStatsReport> report = GetStatsFromCaller();
+ scoped_refptr<const RTCStatsReport> report = GetStatsFromCaller();
RTCStatsReportVerifier(report.get()).VerifyReport({});
}
TEST_F(RTCStatsIntegrationTest, GetStatsFromCallee) {
StartCall();
- rtc::scoped_refptr<const RTCStatsReport> report;
+ scoped_refptr<const RTCStatsReport> report;
// Wait for round trip time measurements to be defined.
constexpr int kMaxWaitMs = 10000;
auto GetStatsReportAndReturnTrueIfRttIsDefined = [&report, this] {
@@ -1053,7 +1051,7 @@
TEST_F(RTCStatsIntegrationTest, GetStatsWithSenderSelector) {
StartCall();
ASSERT_FALSE(caller_->pc()->GetSenders().empty());
- rtc::scoped_refptr<const RTCStatsReport> report =
+ scoped_refptr<const RTCStatsReport> report =
GetStatsFromCaller(caller_->pc()->GetSenders()[0]);
std::vector<const char*> allowed_missing_stats = {
// TODO(hbos): Include RTC[Audio/Video]ReceiverStats when implemented.
@@ -1071,7 +1069,7 @@
StartCall();
ASSERT_FALSE(caller_->pc()->GetReceivers().empty());
- rtc::scoped_refptr<const RTCStatsReport> report =
+ scoped_refptr<const RTCStatsReport> report =
GetStatsFromCaller(caller_->pc()->GetReceivers()[0]);
std::vector<const char*> allowed_missing_stats = {
// TODO(hbos): Include RTC[Audio/Video]SenderStats when implemented.
@@ -1091,7 +1089,7 @@
ASSERT_FALSE(callee_->pc()->GetSenders().empty());
// The selector is invalid for the caller because it belongs to the callee.
auto invalid_selector = callee_->pc()->GetSenders()[0];
- rtc::scoped_refptr<const RTCStatsReport> report =
+ scoped_refptr<const RTCStatsReport> report =
GetStatsFromCaller(invalid_selector);
EXPECT_FALSE(report->size());
}
@@ -1102,7 +1100,7 @@
ASSERT_FALSE(callee_->pc()->GetReceivers().empty());
// The selector is invalid for the caller because it belongs to the callee.
auto invalid_selector = callee_->pc()->GetReceivers()[0];
- rtc::scoped_refptr<const RTCStatsReport> report =
+ scoped_refptr<const RTCStatsReport> report =
GetStatsFromCaller(invalid_selector);
EXPECT_FALSE(report->size());
}
@@ -1114,8 +1112,7 @@
DISABLED_GetStatsWhileDestroyingPeerConnection) {
StartCall();
- rtc::scoped_refptr<RTCStatsObtainer> stats_obtainer =
- RTCStatsObtainer::Create();
+ scoped_refptr<RTCStatsObtainer> stats_obtainer = RTCStatsObtainer::Create();
caller_->pc()->GetStats(stats_obtainer.get());
// This will destroy the peer connection.
caller_ = nullptr;
@@ -1127,8 +1124,7 @@
TEST_F(RTCStatsIntegrationTest, GetsStatsWhileClosingPeerConnection) {
StartCall();
- rtc::scoped_refptr<RTCStatsObtainer> stats_obtainer =
- RTCStatsObtainer::Create();
+ scoped_refptr<RTCStatsObtainer> stats_obtainer = RTCStatsObtainer::Create();
caller_->pc()->GetStats(stats_obtainer.get());
caller_->pc()->Close();
@@ -1145,7 +1141,7 @@
TEST_F(RTCStatsIntegrationTest, GetStatsReferencedIds) {
StartCall();
- rtc::scoped_refptr<const RTCStatsReport> report = GetStatsFromCallee();
+ scoped_refptr<const RTCStatsReport> report = GetStatsFromCallee();
for (const RTCStats& stats : *report) {
// Find all references by looking at all string attributes with the "Id" or
// "Ids" suffix.
@@ -1180,7 +1176,7 @@
TEST_F(RTCStatsIntegrationTest, GetStatsContainsNoDuplicateAttributes) {
StartCall();
- rtc::scoped_refptr<const RTCStatsReport> report = GetStatsFromCallee();
+ scoped_refptr<const RTCStatsReport> report = GetStatsFromCallee();
for (const RTCStats& stats : *report) {
std::set<std::string> attribute_names;
for (const auto& attribute : stats.Attributes()) {
diff --git a/pc/rtc_stats_traversal.cc b/pc/rtc_stats_traversal.cc
index de2475b..a28d606 100644
--- a/pc/rtc_stats_traversal.cc
+++ b/pc/rtc_stats_traversal.cc
@@ -54,10 +54,10 @@
} // namespace
-rtc::scoped_refptr<RTCStatsReport> TakeReferencedStats(
- rtc::scoped_refptr<RTCStatsReport> report,
+scoped_refptr<RTCStatsReport> TakeReferencedStats(
+ scoped_refptr<RTCStatsReport> report,
const std::vector<std::string>& ids) {
- rtc::scoped_refptr<RTCStatsReport> result =
+ scoped_refptr<RTCStatsReport> result =
RTCStatsReport::Create(report->timestamp());
for (const auto& id : ids) {
TraverseAndTakeVisitedStats(report.get(), result.get(), id);
diff --git a/pc/rtc_stats_traversal.h b/pc/rtc_stats_traversal.h
index ec4d51c..9316140 100644
--- a/pc/rtc_stats_traversal.h
+++ b/pc/rtc_stats_traversal.h
@@ -25,8 +25,8 @@
// `ids`, returning them as a new stats report.
// This is meant to be used to implement the stats selection algorithm.
// https://w3c.github.io/webrtc-pc/#dfn-stats-selection-algorithm
-rtc::scoped_refptr<RTCStatsReport> TakeReferencedStats(
- rtc::scoped_refptr<RTCStatsReport> report,
+scoped_refptr<RTCStatsReport> TakeReferencedStats(
+ scoped_refptr<RTCStatsReport> report,
const std::vector<std::string>& ids);
// Gets pointers to the string values of any members in `stats` that are used as
diff --git a/pc/rtc_stats_traversal_unittest.cc b/pc/rtc_stats_traversal_unittest.cc
index c8f106f..2964ead 100644
--- a/pc/rtc_stats_traversal_unittest.cc
+++ b/pc/rtc_stats_traversal_unittest.cc
@@ -74,8 +74,8 @@
}
protected:
- rtc::scoped_refptr<RTCStatsReport> initial_report_;
- rtc::scoped_refptr<RTCStatsReport> result_;
+ scoped_refptr<RTCStatsReport> initial_report_;
+ scoped_refptr<RTCStatsReport> result_;
// Raw pointers to stats owned by the reports.
RTCTransportStats* transport_;
RTCIceCandidatePairStats* candidate_pair_;
diff --git a/pc/rtcp_mux_filter_unittest.cc b/pc/rtcp_mux_filter_unittest.cc
index 14586ab..d314b16 100644
--- a/pc/rtcp_mux_filter_unittest.cc
+++ b/pc/rtcp_mux_filter_unittest.cc
@@ -20,12 +20,12 @@
EXPECT_FALSE(filter.IsProvisionallyActive());
EXPECT_FALSE(filter.IsFullyActive());
// After sent offer, demux should not be active.
- filter.SetOffer(true, cricket::CS_LOCAL);
+ filter.SetOffer(true, webrtc::CS_LOCAL);
EXPECT_FALSE(filter.IsActive());
EXPECT_FALSE(filter.IsProvisionallyActive());
EXPECT_FALSE(filter.IsFullyActive());
// Remote accepted, filter is now active.
- filter.SetAnswer(true, cricket::CS_REMOTE);
+ filter.SetAnswer(true, webrtc::CS_REMOTE);
EXPECT_TRUE(filter.IsActive());
EXPECT_FALSE(filter.IsProvisionallyActive());
EXPECT_TRUE(filter.IsFullyActive());
@@ -34,21 +34,21 @@
// Test that we can receive provisional answer and final answer.
TEST(RtcpMuxFilterTest, ReceivePrAnswer) {
webrtc::RtcpMuxFilter filter;
- filter.SetOffer(true, cricket::CS_LOCAL);
+ filter.SetOffer(true, webrtc::CS_LOCAL);
// Received provisional answer with mux enabled.
- EXPECT_TRUE(filter.SetProvisionalAnswer(true, cricket::CS_REMOTE));
+ EXPECT_TRUE(filter.SetProvisionalAnswer(true, webrtc::CS_REMOTE));
// We are now provisionally active since both sender and receiver support mux.
EXPECT_TRUE(filter.IsActive());
EXPECT_TRUE(filter.IsProvisionallyActive());
EXPECT_FALSE(filter.IsFullyActive());
// Received provisional answer with mux disabled.
- EXPECT_TRUE(filter.SetProvisionalAnswer(false, cricket::CS_REMOTE));
+ EXPECT_TRUE(filter.SetProvisionalAnswer(false, webrtc::CS_REMOTE));
// We are now inactive since the receiver doesn't support mux.
EXPECT_FALSE(filter.IsActive());
EXPECT_FALSE(filter.IsProvisionallyActive());
EXPECT_FALSE(filter.IsFullyActive());
// Received final answer with mux enabled.
- EXPECT_TRUE(filter.SetAnswer(true, cricket::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(true, webrtc::CS_REMOTE));
EXPECT_TRUE(filter.IsActive());
EXPECT_FALSE(filter.IsProvisionallyActive());
EXPECT_TRUE(filter.IsFullyActive());
@@ -61,12 +61,12 @@
EXPECT_FALSE(filter.IsProvisionallyActive());
EXPECT_FALSE(filter.IsFullyActive());
// After received offer, demux should not be active
- filter.SetOffer(true, cricket::CS_REMOTE);
+ filter.SetOffer(true, webrtc::CS_REMOTE);
EXPECT_FALSE(filter.IsActive());
EXPECT_FALSE(filter.IsProvisionallyActive());
EXPECT_FALSE(filter.IsFullyActive());
// We accept, filter is now active
- filter.SetAnswer(true, cricket::CS_LOCAL);
+ filter.SetAnswer(true, webrtc::CS_LOCAL);
EXPECT_TRUE(filter.IsActive());
EXPECT_FALSE(filter.IsProvisionallyActive());
EXPECT_TRUE(filter.IsFullyActive());
@@ -75,19 +75,19 @@
// Test that we can send provisional answer and final answer.
TEST(RtcpMuxFilterTest, SendPrAnswer) {
webrtc::RtcpMuxFilter filter;
- filter.SetOffer(true, cricket::CS_REMOTE);
+ filter.SetOffer(true, webrtc::CS_REMOTE);
// Send provisional answer with mux enabled.
- EXPECT_TRUE(filter.SetProvisionalAnswer(true, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.SetProvisionalAnswer(true, webrtc::CS_LOCAL));
EXPECT_TRUE(filter.IsActive());
EXPECT_TRUE(filter.IsProvisionallyActive());
EXPECT_FALSE(filter.IsFullyActive());
// Received provisional answer with mux disabled.
- EXPECT_TRUE(filter.SetProvisionalAnswer(false, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.SetProvisionalAnswer(false, webrtc::CS_LOCAL));
EXPECT_FALSE(filter.IsActive());
EXPECT_FALSE(filter.IsProvisionallyActive());
EXPECT_FALSE(filter.IsFullyActive());
// Send final answer with mux enabled.
- EXPECT_TRUE(filter.SetAnswer(true, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.SetAnswer(true, webrtc::CS_LOCAL));
EXPECT_TRUE(filter.IsActive());
EXPECT_FALSE(filter.IsProvisionallyActive());
EXPECT_TRUE(filter.IsFullyActive());
@@ -99,16 +99,16 @@
TEST(RtcpMuxFilterTest, EnableFilterDuringUpdate) {
webrtc::RtcpMuxFilter filter;
EXPECT_FALSE(filter.IsActive());
- EXPECT_TRUE(filter.SetOffer(false, cricket::CS_REMOTE));
- EXPECT_TRUE(filter.SetAnswer(false, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.SetOffer(false, webrtc::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(false, webrtc::CS_LOCAL));
EXPECT_FALSE(filter.IsActive());
- EXPECT_TRUE(filter.SetOffer(true, cricket::CS_REMOTE));
- EXPECT_TRUE(filter.SetAnswer(true, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.SetOffer(true, webrtc::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(true, webrtc::CS_LOCAL));
EXPECT_TRUE(filter.IsActive());
- EXPECT_FALSE(filter.SetOffer(false, cricket::CS_REMOTE));
- EXPECT_FALSE(filter.SetAnswer(false, cricket::CS_LOCAL));
+ EXPECT_FALSE(filter.SetOffer(false, webrtc::CS_REMOTE));
+ EXPECT_FALSE(filter.SetAnswer(false, webrtc::CS_LOCAL));
EXPECT_TRUE(filter.IsActive());
}
@@ -116,15 +116,15 @@
TEST(RtcpMuxFilterTest, SetOfferTwice) {
webrtc::RtcpMuxFilter filter;
- EXPECT_TRUE(filter.SetOffer(true, cricket::CS_REMOTE));
- EXPECT_TRUE(filter.SetOffer(true, cricket::CS_REMOTE));
- EXPECT_TRUE(filter.SetAnswer(true, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.SetOffer(true, webrtc::CS_REMOTE));
+ EXPECT_TRUE(filter.SetOffer(true, webrtc::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(true, webrtc::CS_LOCAL));
EXPECT_TRUE(filter.IsActive());
webrtc::RtcpMuxFilter filter2;
- EXPECT_TRUE(filter2.SetOffer(false, cricket::CS_LOCAL));
- EXPECT_TRUE(filter2.SetOffer(false, cricket::CS_LOCAL));
- EXPECT_TRUE(filter2.SetAnswer(false, cricket::CS_REMOTE));
+ EXPECT_TRUE(filter2.SetOffer(false, webrtc::CS_LOCAL));
+ EXPECT_TRUE(filter2.SetOffer(false, webrtc::CS_LOCAL));
+ EXPECT_TRUE(filter2.SetAnswer(false, webrtc::CS_REMOTE));
EXPECT_FALSE(filter2.IsActive());
}
@@ -132,12 +132,12 @@
TEST(RtcpMuxFilterTest, EnableFilterTwiceDuringUpdate) {
webrtc::RtcpMuxFilter filter;
- EXPECT_TRUE(filter.SetOffer(true, cricket::CS_REMOTE));
- EXPECT_TRUE(filter.SetAnswer(true, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.SetOffer(true, webrtc::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(true, webrtc::CS_LOCAL));
EXPECT_TRUE(filter.IsActive());
- EXPECT_TRUE(filter.SetOffer(true, cricket::CS_REMOTE));
- EXPECT_TRUE(filter.SetAnswer(true, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.SetOffer(true, webrtc::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(true, webrtc::CS_LOCAL));
EXPECT_TRUE(filter.IsActive());
}
@@ -145,12 +145,12 @@
TEST(RtcpMuxFilterTest, KeepFilterDisabledDuringUpdate) {
webrtc::RtcpMuxFilter filter;
- EXPECT_TRUE(filter.SetOffer(false, cricket::CS_REMOTE));
- EXPECT_TRUE(filter.SetAnswer(false, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.SetOffer(false, webrtc::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(false, webrtc::CS_LOCAL));
EXPECT_FALSE(filter.IsActive());
- EXPECT_TRUE(filter.SetOffer(false, cricket::CS_REMOTE));
- EXPECT_TRUE(filter.SetAnswer(false, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.SetOffer(false, webrtc::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(false, webrtc::CS_LOCAL));
EXPECT_FALSE(filter.IsActive());
}
@@ -161,33 +161,33 @@
filter.SetActive();
EXPECT_TRUE(filter.IsActive());
- EXPECT_FALSE(filter.SetOffer(false, cricket::CS_LOCAL));
+ EXPECT_FALSE(filter.SetOffer(false, webrtc::CS_LOCAL));
EXPECT_TRUE(filter.IsActive());
- EXPECT_TRUE(filter.SetOffer(true, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.SetOffer(true, webrtc::CS_LOCAL));
EXPECT_TRUE(filter.IsActive());
- EXPECT_FALSE(filter.SetProvisionalAnswer(false, cricket::CS_REMOTE));
+ EXPECT_FALSE(filter.SetProvisionalAnswer(false, webrtc::CS_REMOTE));
EXPECT_TRUE(filter.IsActive());
- EXPECT_TRUE(filter.SetProvisionalAnswer(true, cricket::CS_REMOTE));
+ EXPECT_TRUE(filter.SetProvisionalAnswer(true, webrtc::CS_REMOTE));
EXPECT_TRUE(filter.IsActive());
- EXPECT_FALSE(filter.SetAnswer(false, cricket::CS_REMOTE));
+ EXPECT_FALSE(filter.SetAnswer(false, webrtc::CS_REMOTE));
EXPECT_TRUE(filter.IsActive());
- EXPECT_TRUE(filter.SetAnswer(true, cricket::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(true, webrtc::CS_REMOTE));
EXPECT_TRUE(filter.IsActive());
- EXPECT_FALSE(filter.SetOffer(false, cricket::CS_REMOTE));
+ EXPECT_FALSE(filter.SetOffer(false, webrtc::CS_REMOTE));
EXPECT_TRUE(filter.IsActive());
- EXPECT_TRUE(filter.SetOffer(true, cricket::CS_REMOTE));
+ EXPECT_TRUE(filter.SetOffer(true, webrtc::CS_REMOTE));
EXPECT_TRUE(filter.IsActive());
- EXPECT_FALSE(filter.SetProvisionalAnswer(false, cricket::CS_LOCAL));
+ EXPECT_FALSE(filter.SetProvisionalAnswer(false, webrtc::CS_LOCAL));
EXPECT_TRUE(filter.IsActive());
- EXPECT_TRUE(filter.SetProvisionalAnswer(true, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.SetProvisionalAnswer(true, webrtc::CS_LOCAL));
EXPECT_TRUE(filter.IsActive());
- EXPECT_FALSE(filter.SetAnswer(false, cricket::CS_LOCAL));
+ EXPECT_FALSE(filter.SetAnswer(false, webrtc::CS_LOCAL));
EXPECT_TRUE(filter.IsActive());
- EXPECT_TRUE(filter.SetAnswer(true, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.SetAnswer(true, webrtc::CS_LOCAL));
EXPECT_TRUE(filter.IsActive());
}
diff --git a/pc/rtp_parameters_conversion.cc b/pc/rtp_parameters_conversion.cc
index 72b03b2..75a69bc 100644
--- a/pc/rtp_parameters_conversion.cc
+++ b/pc/rtp_parameters_conversion.cc
@@ -105,7 +105,7 @@
RtpCapabilities ToRtpCapabilities(
const std::vector<Codec>& cricket_codecs,
- const cricket::RtpHeaderExtensions& cricket_extensions) {
+ const RtpHeaderExtensions& cricket_extensions) {
RtpCapabilities capabilities;
bool have_red = false;
bool have_ulpfec = false;
diff --git a/pc/rtp_parameters_conversion.h b/pc/rtp_parameters_conversion.h
index 1247b01..e32bc2e 100644
--- a/pc/rtp_parameters_conversion.h
+++ b/pc/rtp_parameters_conversion.h
@@ -23,7 +23,7 @@
namespace webrtc {
//*****************************************************************************
-// Functions for converting from old cricket:: structures to new webrtc::
+// Functions for converting from old webrtc:: structures to new webrtc::
// structures. These are permissive with regards to
// input validation; it's assumed that any necessary validation already
// occurred.
@@ -41,7 +41,7 @@
RtpCapabilities ToRtpCapabilities(
const std::vector<Codec>& cricket_codecs,
- const cricket::RtpHeaderExtensions& cricket_extensions);
+ const RtpHeaderExtensions& cricket_extensions);
} // namespace webrtc
diff --git a/pc/rtp_parameters_conversion_unittest.cc b/pc/rtp_parameters_conversion_unittest.cc
index 112d12e..407c535 100644
--- a/pc/rtp_parameters_conversion_unittest.cc
+++ b/pc/rtp_parameters_conversion_unittest.cc
@@ -165,15 +165,14 @@
EXPECT_EQ(3, capabilities.header_extensions[1].preferred_id);
EXPECT_EQ(0u, capabilities.fec.size());
- capabilities = ToRtpCapabilities({vp8, red, red2, ulpfec, rtx},
- cricket::RtpHeaderExtensions());
+ capabilities =
+ ToRtpCapabilities({vp8, red, red2, ulpfec, rtx}, RtpHeaderExtensions());
EXPECT_EQ(4u, capabilities.codecs.size());
EXPECT_THAT(
capabilities.fec,
UnorderedElementsAre(FecMechanism::RED, FecMechanism::RED_AND_ULPFEC));
- capabilities =
- ToRtpCapabilities({vp8, red, flexfec}, cricket::RtpHeaderExtensions());
+ capabilities = ToRtpCapabilities({vp8, red, flexfec}, RtpHeaderExtensions());
EXPECT_EQ(3u, capabilities.codecs.size());
EXPECT_THAT(capabilities.fec,
UnorderedElementsAre(FecMechanism::RED, FecMechanism::FLEXFEC));
diff --git a/pc/rtp_receiver.cc b/pc/rtp_receiver.cc
index 28187f2..e09c893 100644
--- a/pc/rtp_receiver.cc
+++ b/pc/rtp_receiver.cc
@@ -34,10 +34,9 @@
return ++g_unique_id;
}
-std::vector<rtc::scoped_refptr<MediaStreamInterface>>
+std::vector<scoped_refptr<MediaStreamInterface>>
RtpReceiverInternal::CreateStreamsFromIds(std::vector<std::string> stream_ids) {
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams(
- stream_ids.size());
+ std::vector<scoped_refptr<MediaStreamInterface>> streams(stream_ids.size());
for (size_t i = 0; i < stream_ids.size(); ++i) {
streams[i] = MediaStreamProxy::Create(
Thread::Current(), MediaStream::Create(std::move(stream_ids[i])));
diff --git a/pc/rtp_receiver.h b/pc/rtp_receiver.h
index 9b145f0..db3ba3e 100644
--- a/pc/rtp_receiver.h
+++ b/pc/rtp_receiver.h
@@ -10,7 +10,7 @@
// This file contains classes that implement RtpReceiverInterface.
// An RtpReceiver associates a MediaStreamTrackInterface with an underlying
-// transport (provided by cricket::VoiceChannel/cricket::VideoChannel)
+// transport (provided by webrtc::VoiceChannel/webrtc::VideoChannel)
#ifndef PC_RTP_RECEIVER_H_
#define PC_RTP_RECEIVER_H_
@@ -55,7 +55,7 @@
virtual void SetupUnsignaledMediaChannel() = 0;
virtual void set_transport(
- rtc::scoped_refptr<DtlsTransportInterface> dtls_transport) = 0;
+ scoped_refptr<DtlsTransportInterface> dtls_transport) = 0;
// This SSRC is used as an identifier for the receiver between the API layer
// and the WebRtcVideoEngine, WebRtcVoiceEngine layer.
virtual std::optional<uint32_t> ssrc() const = 0;
@@ -72,7 +72,7 @@
// set_stream_ids() as soon as downstream projects are no longer dependent on
// stream objects.
virtual void SetStreams(
- const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) = 0;
+ const std::vector<scoped_refptr<MediaStreamInterface>>& streams) = 0;
// Returns an ID that changes if the attached track changes, but
// otherwise remains constant. Used to generate IDs for stats.
@@ -82,8 +82,8 @@
protected:
static int GenerateUniqueId();
- static std::vector<rtc::scoped_refptr<MediaStreamInterface>>
- CreateStreamsFromIds(std::vector<std::string> stream_ids);
+ static std::vector<scoped_refptr<MediaStreamInterface>> CreateStreamsFromIds(
+ std::vector<std::string> stream_ids);
};
} // namespace webrtc
diff --git a/pc/rtp_receiver_proxy.h b/pc/rtp_receiver_proxy.h
index 55c8d9a..223b307 100644
--- a/pc/rtp_receiver_proxy.h
+++ b/pc/rtp_receiver_proxy.h
@@ -33,11 +33,10 @@
// an implementation detail.
BEGIN_PROXY_MAP(RtpReceiver)
PROXY_PRIMARY_THREAD_DESTRUCTOR()
-BYPASS_PROXY_CONSTMETHOD0(rtc::scoped_refptr<MediaStreamTrackInterface>, track)
-PROXY_CONSTMETHOD0(rtc::scoped_refptr<DtlsTransportInterface>, dtls_transport)
+BYPASS_PROXY_CONSTMETHOD0(scoped_refptr<MediaStreamTrackInterface>, track)
+PROXY_CONSTMETHOD0(scoped_refptr<DtlsTransportInterface>, dtls_transport)
PROXY_CONSTMETHOD0(std::vector<std::string>, stream_ids)
-PROXY_CONSTMETHOD0(std::vector<rtc::scoped_refptr<MediaStreamInterface>>,
- streams)
+PROXY_CONSTMETHOD0(std::vector<scoped_refptr<MediaStreamInterface>>, streams)
BYPASS_PROXY_CONSTMETHOD0(webrtc::MediaType, media_type)
BYPASS_PROXY_CONSTMETHOD0(std::string, id)
PROXY_SECONDARY_CONSTMETHOD0(RtpParameters, GetParameters)
@@ -49,13 +48,13 @@
// TODO(bugs.webrtc.org/12772): Remove.
PROXY_SECONDARY_METHOD1(void,
SetFrameDecryptor,
- rtc::scoped_refptr<FrameDecryptorInterface>)
+ scoped_refptr<FrameDecryptorInterface>)
// TODO(bugs.webrtc.org/12772): Remove.
-PROXY_SECONDARY_CONSTMETHOD0(rtc::scoped_refptr<FrameDecryptorInterface>,
+PROXY_SECONDARY_CONSTMETHOD0(scoped_refptr<FrameDecryptorInterface>,
GetFrameDecryptor)
PROXY_SECONDARY_METHOD1(void,
SetFrameTransformer,
- rtc::scoped_refptr<FrameTransformerInterface>)
+ scoped_refptr<FrameTransformerInterface>)
END_PROXY_MAP(RtpReceiver)
} // namespace webrtc
diff --git a/pc/rtp_sender.cc b/pc/rtp_sender.cc
index 22e4c23..31bbba0 100644
--- a/pc/rtp_sender.cc
+++ b/pc/rtp_sender.cc
@@ -184,7 +184,7 @@
}
void RtpSenderBase::SetFrameEncryptor(
- rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor) {
+ scoped_refptr<FrameEncryptorInterface> frame_encryptor) {
RTC_DCHECK_RUN_ON(signaling_thread_);
frame_encryptor_ = std::move(frame_encryptor);
// Special Case: Set the frame encryptor to any value on any existing channel.
@@ -482,7 +482,7 @@
// Attach to new track.
bool prev_can_send_track = can_send_track();
// Keep a reference to the old track to keep it alive until we call SetSend.
- rtc::scoped_refptr<MediaStreamTrackInterface> old_track = track_;
+ scoped_refptr<MediaStreamTrackInterface> old_track = track_;
track_ = track;
if (track_) {
track_->RegisterObserver(this);
@@ -629,7 +629,7 @@
}
void RtpSenderBase::SetFrameTransformer(
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) {
+ scoped_refptr<FrameTransformerInterface> frame_transformer) {
RTC_DCHECK_RUN_ON(signaling_thread_);
frame_transformer_ = std::move(frame_transformer);
if (media_channel_ && ssrc_ && !stopped_) {
@@ -671,14 +671,14 @@
sink_ = sink;
}
-rtc::scoped_refptr<AudioRtpSender> AudioRtpSender::Create(
+scoped_refptr<AudioRtpSender> AudioRtpSender::Create(
const webrtc::Environment& env,
Thread* worker_thread,
const std::string& id,
LegacyStatsCollectorInterface* stats,
SetStreamsObserver* set_streams_observer) {
- return rtc::make_ref_counted<AudioRtpSender>(env, worker_thread, id, stats,
- set_streams_observer);
+ return make_ref_counted<AudioRtpSender>(env, worker_thread, id, stats,
+ set_streams_observer);
}
AudioRtpSender::AudioRtpSender(const webrtc::Environment& env,
@@ -765,7 +765,7 @@
}
}
-rtc::scoped_refptr<DtmfSenderInterface> AudioRtpSender::GetDtmfSender() const {
+scoped_refptr<DtmfSenderInterface> AudioRtpSender::GetDtmfSender() const {
RTC_DCHECK_RUN_ON(signaling_thread_);
return dtmf_sender_proxy_;
}
@@ -826,13 +826,13 @@
}
}
-rtc::scoped_refptr<VideoRtpSender> VideoRtpSender::Create(
+scoped_refptr<VideoRtpSender> VideoRtpSender::Create(
const Environment& env,
Thread* worker_thread,
const std::string& id,
SetStreamsObserver* set_streams_observer) {
- return rtc::make_ref_counted<VideoRtpSender>(env, worker_thread, id,
- set_streams_observer);
+ return make_ref_counted<VideoRtpSender>(env, worker_thread, id,
+ set_streams_observer);
}
VideoRtpSender::VideoRtpSender(const Environment& env,
@@ -864,7 +864,7 @@
cached_track_content_hint_ = video_track()->content_hint();
}
-rtc::scoped_refptr<DtmfSenderInterface> VideoRtpSender::GetDtmfSender() const {
+scoped_refptr<DtmfSenderInterface> VideoRtpSender::GetDtmfSender() const {
RTC_DCHECK_RUN_ON(signaling_thread_);
RTC_DLOG(LS_ERROR) << "Tried to get DTMF sender from video sender.";
return nullptr;
diff --git a/pc/rtp_sender.h b/pc/rtp_sender.h
index 2d61741..ef7310f 100644
--- a/pc/rtp_sender.h
+++ b/pc/rtp_sender.h
@@ -68,7 +68,7 @@
virtual void set_init_send_encodings(
const std::vector<RtpEncodingParameters>& init_send_encodings) = 0;
virtual void set_transport(
- rtc::scoped_refptr<DtlsTransportInterface> dtls_transport) = 0;
+ scoped_refptr<DtlsTransportInterface> dtls_transport) = 0;
virtual void Stop() = 0;
@@ -125,7 +125,7 @@
void SetMediaChannel(MediaSendChannelInterface* media_channel) override;
bool SetTrack(MediaStreamTrackInterface* track) override;
- rtc::scoped_refptr<MediaStreamTrackInterface> track() const override {
+ scoped_refptr<MediaStreamTrackInterface> track() const override {
// This method is currently called from the worker thread by
// RTCStatsCollector::PrepareTransceiverStatsInfosAndCallStats_s_w_n.
// RTC_DCHECK_RUN_ON(signaling_thread_);
@@ -182,19 +182,18 @@
}
void set_transport(
- rtc::scoped_refptr<DtlsTransportInterface> dtls_transport) override {
+ scoped_refptr<DtlsTransportInterface> dtls_transport) override {
dtls_transport_ = dtls_transport;
}
- rtc::scoped_refptr<DtlsTransportInterface> dtls_transport() const override {
+ scoped_refptr<DtlsTransportInterface> dtls_transport() const override {
RTC_DCHECK_RUN_ON(signaling_thread_);
return dtls_transport_;
}
void SetFrameEncryptor(
- rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor) override;
+ scoped_refptr<FrameEncryptorInterface> frame_encryptor) override;
- rtc::scoped_refptr<FrameEncryptorInterface> GetFrameEncryptor()
- const override {
+ scoped_refptr<FrameEncryptorInterface> GetFrameEncryptor() const override {
return frame_encryptor_;
}
@@ -210,7 +209,7 @@
RTCError DisableEncodingLayers(const std::vector<std::string>& rid) override;
void SetFrameTransformer(
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) override;
+ scoped_refptr<FrameTransformerInterface> frame_transformer) override;
void SetEncoderSelector(
std::unique_ptr<VideoEncoderFactory::EncoderSelectorInterface>
@@ -276,10 +275,10 @@
// remove since the upstream code may already be performing several operations
// on the worker thread.
MediaSendChannelInterface* media_channel_ = nullptr;
- rtc::scoped_refptr<MediaStreamTrackInterface> track_;
+ scoped_refptr<MediaStreamTrackInterface> track_;
- rtc::scoped_refptr<DtlsTransportInterface> dtls_transport_;
- rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor_;
+ scoped_refptr<DtlsTransportInterface> dtls_transport_;
+ scoped_refptr<FrameEncryptorInterface> frame_encryptor_;
// `last_transaction_id_` is used to verify that `SetParameters` is receiving
// the parameters object that was last returned from `GetParameters`.
// As such, it is used for internal verification and is not observable by the
@@ -292,7 +291,7 @@
RtpSenderObserverInterface* observer_ = nullptr;
bool sent_first_packet_ = false;
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer_;
+ scoped_refptr<FrameTransformerInterface> frame_transformer_;
std::unique_ptr<VideoEncoderFactory::EncoderSelectorInterface>
encoder_selector_;
@@ -330,7 +329,7 @@
// AudioSinkInterface implementation.
int NumPreferredChannels() const override { return num_preferred_channels_; }
- // cricket::AudioSource implementation.
+ // webrtc::AudioSource implementation.
void SetSink(AudioSource::Sink* sink) override;
AudioSource::Sink* sink_;
@@ -348,7 +347,7 @@
// If `set_streams_observer` is not null, it is invoked when SetStreams()
// is called. `set_streams_observer` is not owned by this object. If not
// null, it must be valid at least until this sender becomes stopped.
- static rtc::scoped_refptr<AudioRtpSender> Create(
+ static scoped_refptr<AudioRtpSender> Create(
const Environment& env,
Thread* worker_thread,
const std::string& id,
@@ -370,7 +369,7 @@
return MediaStreamTrackInterface::kAudioKind;
}
- rtc::scoped_refptr<DtmfSenderInterface> GetDtmfSender() const override;
+ scoped_refptr<DtmfSenderInterface> GetDtmfSender() const override;
RTCError GenerateKeyFrame(const std::vector<std::string>& rids) override;
protected:
@@ -393,18 +392,18 @@
VoiceMediaSendChannelInterface* voice_media_channel() {
return media_channel_->AsVoiceSendChannel();
}
- rtc::scoped_refptr<AudioTrackInterface> audio_track() const {
- return rtc::scoped_refptr<AudioTrackInterface>(
+ scoped_refptr<AudioTrackInterface> audio_track() const {
+ return scoped_refptr<AudioTrackInterface>(
static_cast<AudioTrackInterface*>(track_.get()));
}
LegacyStatsCollectorInterface* legacy_stats_ = nullptr;
- rtc::scoped_refptr<DtmfSender> dtmf_sender_;
- rtc::scoped_refptr<DtmfSenderInterface> dtmf_sender_proxy_;
+ scoped_refptr<DtmfSender> dtmf_sender_;
+ scoped_refptr<DtmfSenderInterface> dtmf_sender_proxy_;
bool cached_track_enabled_ = false;
// Used to pass the data callback from the `track_` to the other end of
- // cricket::AudioSource.
+ // webrtc::AudioSource.
std::unique_ptr<LocalAudioSinkAdapter> sink_adapter_;
};
@@ -415,7 +414,7 @@
// If `set_streams_observer` is not null, it is invoked when SetStreams()
// is called. `set_streams_observer` is not owned by this object. If not
// null, it must be valid at least until this sender becomes stopped.
- static rtc::scoped_refptr<VideoRtpSender> Create(
+ static scoped_refptr<VideoRtpSender> Create(
const Environment& env,
Thread* worker_thread,
const std::string& id,
@@ -432,7 +431,7 @@
return MediaStreamTrackInterface::kVideoKind;
}
- rtc::scoped_refptr<DtmfSenderInterface> GetDtmfSender() const override;
+ scoped_refptr<DtmfSenderInterface> GetDtmfSender() const override;
RTCError GenerateKeyFrame(const std::vector<std::string>& rids) override;
protected:
@@ -451,8 +450,8 @@
VideoMediaSendChannelInterface* video_media_channel() {
return media_channel_->AsVideoSendChannel();
}
- rtc::scoped_refptr<VideoTrackInterface> video_track() const {
- return rtc::scoped_refptr<VideoTrackInterface>(
+ scoped_refptr<VideoTrackInterface> video_track() const {
+ return scoped_refptr<VideoTrackInterface>(
static_cast<VideoTrackInterface*>(track_.get()));
}
diff --git a/pc/rtp_sender_proxy.h b/pc/rtp_sender_proxy.h
index ec63186..ec2f8a9 100644
--- a/pc/rtp_sender_proxy.h
+++ b/pc/rtp_sender_proxy.h
@@ -26,8 +26,8 @@
BEGIN_PRIMARY_PROXY_MAP(RtpSender)
PROXY_PRIMARY_THREAD_DESTRUCTOR()
PROXY_METHOD1(bool, SetTrack, MediaStreamTrackInterface*)
-PROXY_CONSTMETHOD0(rtc::scoped_refptr<MediaStreamTrackInterface>, track)
-PROXY_CONSTMETHOD0(rtc::scoped_refptr<DtlsTransportInterface>, dtls_transport)
+PROXY_CONSTMETHOD0(scoped_refptr<MediaStreamTrackInterface>, track)
+PROXY_CONSTMETHOD0(scoped_refptr<DtlsTransportInterface>, dtls_transport)
PROXY_CONSTMETHOD0(uint32_t, ssrc)
BYPASS_PROXY_CONSTMETHOD0(webrtc::MediaType, media_type)
BYPASS_PROXY_CONSTMETHOD0(std::string, id)
@@ -39,17 +39,14 @@
SetParametersAsync,
const RtpParameters&,
SetParametersCallback)
-PROXY_CONSTMETHOD0(rtc::scoped_refptr<DtmfSenderInterface>, GetDtmfSender)
-PROXY_METHOD1(void,
- SetFrameEncryptor,
- rtc::scoped_refptr<FrameEncryptorInterface>)
+PROXY_CONSTMETHOD0(scoped_refptr<DtmfSenderInterface>, GetDtmfSender)
+PROXY_METHOD1(void, SetFrameEncryptor, scoped_refptr<FrameEncryptorInterface>)
PROXY_METHOD1(void, SetObserver, RtpSenderObserverInterface*)
-PROXY_CONSTMETHOD0(rtc::scoped_refptr<FrameEncryptorInterface>,
- GetFrameEncryptor)
+PROXY_CONSTMETHOD0(scoped_refptr<FrameEncryptorInterface>, GetFrameEncryptor)
PROXY_METHOD1(void, SetStreams, const std::vector<std::string>&)
PROXY_METHOD1(void,
SetFrameTransformer,
- rtc::scoped_refptr<FrameTransformerInterface>)
+ scoped_refptr<FrameTransformerInterface>)
PROXY_METHOD1(void,
SetEncoderSelector,
std::unique_ptr<VideoEncoderFactory::EncoderSelectorInterface>)
diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc
index 46c0c4c..4c5722b 100644
--- a/pc/rtp_sender_receiver_unittest.cc
+++ b/pc/rtp_sender_receiver_unittest.cc
@@ -178,7 +178,7 @@
void AddVideoTrack() { AddVideoTrack(false); }
void AddVideoTrack(bool is_screencast) {
- rtc::scoped_refptr<VideoTrackSourceInterface> source(
+ scoped_refptr<VideoTrackSourceInterface> source(
FakeVideoTrackSource::Create(is_screencast));
video_track_ = VideoTrack::Create(kVideoTrackId, source, Thread::Current());
EXPECT_TRUE(local_stream_->AddTrack(video_track_));
@@ -186,8 +186,7 @@
void CreateAudioRtpSender() { CreateAudioRtpSender(nullptr); }
- void CreateAudioRtpSender(
- const rtc::scoped_refptr<LocalAudioSource>& source) {
+ void CreateAudioRtpSender(const scoped_refptr<LocalAudioSource>& source) {
audio_track_ = AudioTrack::Create(kAudioTrackId, source);
EXPECT_TRUE(local_stream_->AddTrack(audio_track_));
std::unique_ptr<MockSetStreamsObserver> set_streams_observer =
@@ -279,8 +278,8 @@
}
void CreateAudioRtpReceiver(
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams = {}) {
- audio_rtp_receiver_ = rtc::make_ref_counted<AudioRtpReceiver>(
+ std::vector<scoped_refptr<MediaStreamInterface>> streams = {}) {
+ audio_rtp_receiver_ = make_ref_counted<AudioRtpReceiver>(
Thread::Current(), kAudioTrackId, streams,
/*is_unified_plan=*/true);
audio_rtp_receiver_->SetMediaChannel(voice_media_receive_channel());
@@ -290,8 +289,8 @@
}
void CreateVideoRtpReceiver(
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams = {}) {
- video_rtp_receiver_ = rtc::make_ref_counted<VideoRtpReceiver>(
+ std::vector<scoped_refptr<MediaStreamInterface>> streams = {}) {
+ video_rtp_receiver_ = make_ref_counted<VideoRtpReceiver>(
Thread::Current(), kVideoTrackId, streams);
video_rtp_receiver_->SetMediaChannel(video_media_receive_channel());
video_rtp_receiver_->SetupMediaChannel(kVideoSsrc);
@@ -300,7 +299,7 @@
}
void CreateVideoRtpReceiverWithSimulcast(
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams = {},
+ std::vector<scoped_refptr<MediaStreamInterface>> streams = {},
int num_layers = kVideoSimulcastLayerCount) {
std::vector<uint32_t> ssrcs;
ssrcs.reserve(num_layers);
@@ -310,7 +309,7 @@
video_media_receive_channel_->AddRecvStream(stream_params);
uint32_t primary_ssrc = stream_params.first_ssrc();
- video_rtp_receiver_ = rtc::make_ref_counted<VideoRtpReceiver>(
+ video_rtp_receiver_ = make_ref_counted<VideoRtpReceiver>(
Thread::Current(), kVideoTrackId, streams);
video_rtp_receiver_->SetMediaChannel(video_media_receive_channel());
video_rtp_receiver_->SetupMediaChannel(primary_ssrc);
@@ -526,13 +525,13 @@
voice_media_receive_channel_;
std::unique_ptr<VideoMediaReceiveChannelInterface>
video_media_receive_channel_;
- rtc::scoped_refptr<AudioRtpSender> audio_rtp_sender_;
- rtc::scoped_refptr<VideoRtpSender> video_rtp_sender_;
- rtc::scoped_refptr<AudioRtpReceiver> audio_rtp_receiver_;
- rtc::scoped_refptr<VideoRtpReceiver> video_rtp_receiver_;
- rtc::scoped_refptr<MediaStreamInterface> local_stream_;
- rtc::scoped_refptr<VideoTrackInterface> video_track_;
- rtc::scoped_refptr<AudioTrackInterface> audio_track_;
+ scoped_refptr<AudioRtpSender> audio_rtp_sender_;
+ scoped_refptr<VideoRtpSender> video_rtp_sender_;
+ scoped_refptr<AudioRtpReceiver> audio_rtp_receiver_;
+ scoped_refptr<VideoRtpReceiver> video_rtp_receiver_;
+ scoped_refptr<MediaStreamInterface> local_stream_;
+ scoped_refptr<VideoTrackInterface> video_track_;
+ scoped_refptr<AudioTrackInterface> audio_track_;
};
// Test that `voice_channel_` is updated when an audio track is associated
@@ -723,7 +722,7 @@
// doesn't have both a track and SSRC.
TEST_F(RtpSenderReceiverTest, AudioSenderWithoutTrackAndSsrc) {
CreateAudioRtpSenderWithNoTrack();
- rtc::scoped_refptr<AudioTrackInterface> track =
+ scoped_refptr<AudioTrackInterface> track =
AudioTrack::Create(kAudioTrackId, nullptr);
// Track but no SSRC.
@@ -755,7 +754,7 @@
// has a track and SSRC, when the SSRC is set first.
TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupSsrcThenTrack) {
CreateAudioRtpSenderWithNoTrack();
- rtc::scoped_refptr<AudioTrackInterface> track =
+ scoped_refptr<AudioTrackInterface> track =
AudioTrack::Create(kAudioTrackId, nullptr);
audio_rtp_sender_->SetSsrc(kAudioSsrc);
audio_rtp_sender_->SetTrack(track.get());
@@ -768,7 +767,7 @@
// has a track and SSRC, when the SSRC is set last.
TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupTrackThenSsrc) {
CreateAudioRtpSenderWithNoTrack();
- rtc::scoped_refptr<AudioTrackInterface> track =
+ scoped_refptr<AudioTrackInterface> track =
AudioTrack::Create(kAudioTrackId, nullptr);
audio_rtp_sender_->SetTrack(track.get());
audio_rtp_sender_->SetSsrc(kAudioSsrc);
@@ -1788,7 +1787,7 @@
// Validate that the default FrameEncryptor setting is nullptr.
TEST_F(RtpSenderReceiverTest, AudioSenderCanSetFrameEncryptor) {
CreateAudioRtpSender();
- rtc::scoped_refptr<FrameEncryptorInterface> fake_frame_encryptor(
+ scoped_refptr<FrameEncryptorInterface> fake_frame_encryptor(
new FakeFrameEncryptor());
EXPECT_EQ(nullptr, audio_rtp_sender_->GetFrameEncryptor());
audio_rtp_sender_->SetFrameEncryptor(fake_frame_encryptor);
@@ -1800,7 +1799,7 @@
// nothing.
TEST_F(RtpSenderReceiverTest, AudioSenderCannotSetFrameEncryptorAfterStop) {
CreateAudioRtpSender();
- rtc::scoped_refptr<FrameEncryptorInterface> fake_frame_encryptor(
+ scoped_refptr<FrameEncryptorInterface> fake_frame_encryptor(
new FakeFrameEncryptor());
EXPECT_EQ(nullptr, audio_rtp_sender_->GetFrameEncryptor());
audio_rtp_sender_->Stop();
@@ -1811,8 +1810,8 @@
// Validate that the default FrameEncryptor setting is nullptr.
TEST_F(RtpSenderReceiverTest, AudioReceiverCanSetFrameDecryptor) {
CreateAudioRtpReceiver();
- rtc::scoped_refptr<FrameDecryptorInterface> fake_frame_decryptor(
- rtc::make_ref_counted<FakeFrameDecryptor>());
+ scoped_refptr<FrameDecryptorInterface> fake_frame_decryptor(
+ make_ref_counted<FakeFrameDecryptor>());
EXPECT_EQ(nullptr, audio_rtp_receiver_->GetFrameDecryptor());
audio_rtp_receiver_->SetFrameDecryptor(fake_frame_decryptor);
EXPECT_EQ(fake_frame_decryptor.get(),
@@ -1823,8 +1822,8 @@
// Validate that the default FrameEncryptor setting is nullptr.
TEST_F(RtpSenderReceiverTest, AudioReceiverCannotSetFrameDecryptorAfterStop) {
CreateAudioRtpReceiver();
- rtc::scoped_refptr<FrameDecryptorInterface> fake_frame_decryptor(
- rtc::make_ref_counted<FakeFrameDecryptor>());
+ scoped_refptr<FrameDecryptorInterface> fake_frame_decryptor(
+ make_ref_counted<FakeFrameDecryptor>());
EXPECT_EQ(nullptr, audio_rtp_receiver_->GetFrameDecryptor());
audio_rtp_receiver_->SetMediaChannel(nullptr);
audio_rtp_receiver_->SetFrameDecryptor(fake_frame_decryptor);
@@ -1835,7 +1834,7 @@
// Validate that the default FrameEncryptor setting is nullptr.
TEST_F(RtpSenderReceiverTest, VideoSenderCanSetFrameEncryptor) {
CreateVideoRtpSender();
- rtc::scoped_refptr<FrameEncryptorInterface> fake_frame_encryptor(
+ scoped_refptr<FrameEncryptorInterface> fake_frame_encryptor(
new FakeFrameEncryptor());
EXPECT_EQ(nullptr, video_rtp_sender_->GetFrameEncryptor());
video_rtp_sender_->SetFrameEncryptor(fake_frame_encryptor);
@@ -1847,7 +1846,7 @@
// nothing.
TEST_F(RtpSenderReceiverTest, VideoSenderCannotSetFrameEncryptorAfterStop) {
CreateVideoRtpSender();
- rtc::scoped_refptr<FrameEncryptorInterface> fake_frame_encryptor(
+ scoped_refptr<FrameEncryptorInterface> fake_frame_encryptor(
new FakeFrameEncryptor());
EXPECT_EQ(nullptr, video_rtp_sender_->GetFrameEncryptor());
video_rtp_sender_->Stop();
@@ -1858,8 +1857,8 @@
// Validate that the default FrameEncryptor setting is nullptr.
TEST_F(RtpSenderReceiverTest, VideoReceiverCanSetFrameDecryptor) {
CreateVideoRtpReceiver();
- rtc::scoped_refptr<FrameDecryptorInterface> fake_frame_decryptor(
- rtc::make_ref_counted<FakeFrameDecryptor>());
+ scoped_refptr<FrameDecryptorInterface> fake_frame_decryptor(
+ make_ref_counted<FakeFrameDecryptor>());
EXPECT_EQ(nullptr, video_rtp_receiver_->GetFrameDecryptor());
video_rtp_receiver_->SetFrameDecryptor(fake_frame_decryptor);
EXPECT_EQ(fake_frame_decryptor.get(),
@@ -1870,8 +1869,8 @@
// Validate that the default FrameEncryptor setting is nullptr.
TEST_F(RtpSenderReceiverTest, VideoReceiverCannotSetFrameDecryptorAfterStop) {
CreateVideoRtpReceiver();
- rtc::scoped_refptr<FrameDecryptorInterface> fake_frame_decryptor(
- rtc::make_ref_counted<FakeFrameDecryptor>());
+ scoped_refptr<FrameDecryptorInterface> fake_frame_decryptor(
+ make_ref_counted<FakeFrameDecryptor>());
EXPECT_EQ(nullptr, video_rtp_receiver_->GetFrameDecryptor());
video_rtp_receiver_->SetMediaChannel(nullptr);
video_rtp_receiver_->SetFrameDecryptor(fake_frame_decryptor);
diff --git a/pc/rtp_transceiver.cc b/pc/rtp_transceiver.cc
index 55a396c..6dae6e6 100644
--- a/pc/rtp_transceiver.cc
+++ b/pc/rtp_transceiver.cc
@@ -129,9 +129,8 @@
}
RtpTransceiver::RtpTransceiver(
- rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender,
- rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
- receiver,
+ scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender,
+ scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>> receiver,
ConnectionContext* context,
CodecLookupHelper* codec_lookup_helper,
std::vector<RtpHeaderExtensionCapability> header_extensions_to_negotiate,
@@ -395,7 +394,7 @@
}
void RtpTransceiver::AddSender(
- rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender) {
+ scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender) {
RTC_DCHECK_RUN_ON(thread_);
RTC_DCHECK(!stopped_);
RTC_DCHECK(!unified_plan_);
@@ -426,8 +425,7 @@
}
void RtpTransceiver::AddReceiver(
- rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
- receiver) {
+ scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>> receiver) {
RTC_DCHECK_RUN_ON(thread_);
RTC_DCHECK(!stopped_);
RTC_DCHECK(!unified_plan_);
@@ -458,17 +456,16 @@
return true;
}
-rtc::scoped_refptr<RtpSenderInternal> RtpTransceiver::sender_internal() const {
+scoped_refptr<RtpSenderInternal> RtpTransceiver::sender_internal() const {
RTC_DCHECK(unified_plan_);
RTC_CHECK_EQ(1u, senders_.size());
- return rtc::scoped_refptr<RtpSenderInternal>(senders_[0]->internal());
+ return scoped_refptr<RtpSenderInternal>(senders_[0]->internal());
}
-rtc::scoped_refptr<RtpReceiverInternal> RtpTransceiver::receiver_internal()
- const {
+scoped_refptr<RtpReceiverInternal> RtpTransceiver::receiver_internal() const {
RTC_DCHECK(unified_plan_);
RTC_CHECK_EQ(1u, receivers_.size());
- return rtc::scoped_refptr<RtpReceiverInternal>(receivers_[0]->internal());
+ return scoped_refptr<RtpReceiverInternal>(receivers_[0]->internal());
}
webrtc::MediaType RtpTransceiver::media_type() const {
@@ -491,13 +488,13 @@
}
}
-rtc::scoped_refptr<RtpSenderInterface> RtpTransceiver::sender() const {
+scoped_refptr<RtpSenderInterface> RtpTransceiver::sender() const {
RTC_DCHECK(unified_plan_);
RTC_CHECK_EQ(1u, senders_.size());
return senders_[0];
}
-rtc::scoped_refptr<RtpReceiverInterface> RtpTransceiver::receiver() const {
+scoped_refptr<RtpReceiverInterface> RtpTransceiver::receiver() const {
RTC_DCHECK(unified_plan_);
RTC_CHECK_EQ(1u, receivers_.size());
return receivers_[0];
@@ -655,7 +652,7 @@
}
RTCError RtpTransceiver::SetCodecPreferences(
- rtc::ArrayView<RtpCodecCapability> codec_capabilities) {
+ ArrayView<RtpCodecCapability> codec_capabilities) {
RTC_DCHECK(unified_plan_);
// 3. If codecs is an empty list, set transceiver's [[PreferredCodecs]] slot
// to codecs and abort these steps.
@@ -798,7 +795,7 @@
}
RTCError RtpTransceiver::SetHeaderExtensionsToNegotiate(
- rtc::ArrayView<const RtpHeaderExtensionCapability> header_extensions) {
+ ArrayView<const RtpHeaderExtensionCapability> header_extensions) {
// https://w3c.github.io/webrtc-extensions/#dom-rtcrtptransceiver-setheaderextensionstonegotiate
if (header_extensions.size() != header_extensions_to_negotiate_.size()) {
return RTCError(RTCErrorType::INVALID_MODIFICATION,
diff --git a/pc/rtp_transceiver.h b/pc/rtp_transceiver.h
index a076afa..0dde593 100644
--- a/pc/rtp_transceiver.h
+++ b/pc/rtp_transceiver.h
@@ -97,9 +97,8 @@
// `HeaderExtensionsToNegotiate` is used for initializing the return value of
// HeaderExtensionsToNegotiate().
RtpTransceiver(
- rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender,
- rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
- receiver,
+ scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender,
+ scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>> receiver,
ConnectionContext* context,
CodecLookupHelper* codec_lookup_helper,
std::vector<RtpHeaderExtensionCapability> HeaderExtensionsToNegotiate,
@@ -163,14 +162,14 @@
// Adds an RtpSender of the appropriate type to be owned by this transceiver.
// Must not be null.
void AddSender(
- rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender);
+ scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender);
// Removes the given RtpSender. Returns false if the sender is not owned by
// this transceiver.
bool RemoveSender(RtpSenderInterface* sender);
// Returns a vector of the senders owned by this transceiver.
- std::vector<rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>>
+ std::vector<scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>>
senders() const {
return senders_;
}
@@ -178,7 +177,7 @@
// Adds an RtpReceiver of the appropriate type to be owned by this
// transceiver. Must not be null.
void AddReceiver(
- rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
+ scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
receiver);
// Removes the given RtpReceiver. Returns false if the receiver is not owned
@@ -186,17 +185,16 @@
bool RemoveReceiver(RtpReceiverInterface* receiver);
// Returns a vector of the receivers owned by this transceiver.
- std::vector<
- rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>>
+ std::vector<scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>>
receivers() const {
return receivers_;
}
// Returns the backing object for the transceiver's Unified Plan sender.
- rtc::scoped_refptr<RtpSenderInternal> sender_internal() const;
+ scoped_refptr<RtpSenderInternal> sender_internal() const;
// Returns the backing object for the transceiver's Unified Plan receiver.
- rtc::scoped_refptr<RtpReceiverInternal> receiver_internal() const;
+ scoped_refptr<RtpReceiverInternal> receiver_internal() const;
// RtpTransceivers are not associated until they have a corresponding media
// section set in SetLocalDescription or SetRemoteDescription. Therefore,
@@ -262,8 +260,8 @@
// RtpTransceiverInterface implementation.
webrtc::MediaType media_type() const override;
std::optional<std::string> mid() const override;
- rtc::scoped_refptr<RtpSenderInterface> sender() const override;
- rtc::scoped_refptr<RtpReceiverInterface> receiver() const override;
+ scoped_refptr<RtpSenderInterface> sender() const override;
+ scoped_refptr<RtpReceiverInterface> receiver() const override;
bool stopped() const override;
bool stopping() const override;
RtpTransceiverDirection direction() const override;
@@ -273,8 +271,7 @@
std::optional<RtpTransceiverDirection> fired_direction() const override;
RTCError StopStandard() override;
void StopInternal() override;
- RTCError SetCodecPreferences(
- rtc::ArrayView<RtpCodecCapability> codecs) override;
+ RTCError SetCodecPreferences(ArrayView<RtpCodecCapability> codecs) override;
// TODO(https://crbug.com/webrtc/391275081): Delete codec_preferences() in
// favor of filtered_codec_preferences() because it's not used anywhere.
std::vector<RtpCodecCapability> codec_preferences() const override;
@@ -287,8 +284,7 @@
std::vector<RtpHeaderExtensionCapability> GetNegotiatedHeaderExtensions()
const override;
RTCError SetHeaderExtensionsToNegotiate(
- rtc::ArrayView<const RtpHeaderExtensionCapability> header_extensions)
- override;
+ ArrayView<const RtpHeaderExtensionCapability> header_extensions) override;
// Called on the signaling thread when the local or remote content description
// is updated. Used to update the negotiated header extensions.
@@ -329,11 +325,10 @@
TaskQueueBase* const thread_;
const bool unified_plan_;
const webrtc::MediaType media_type_;
- rtc::scoped_refptr<PendingTaskSafetyFlag> signaling_thread_safety_;
- std::vector<rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>>
+ scoped_refptr<PendingTaskSafetyFlag> signaling_thread_safety_;
+ std::vector<scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>>
senders_;
- std::vector<
- rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>>
+ std::vector<scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>>
receivers_;
bool stopped_ RTC_GUARDED_BY(thread_) = false;
@@ -363,8 +358,7 @@
// `negotiated_header_extensions_` is read and written to on the signaling
// thread from the SdpOfferAnswerHandler class (e.g.
// PushdownMediaDescription().
- cricket::RtpHeaderExtensions negotiated_header_extensions_
- RTC_GUARDED_BY(thread_);
+ RtpHeaderExtensions negotiated_header_extensions_ RTC_GUARDED_BY(thread_);
const std::function<void()> on_negotiation_needed_;
};
@@ -374,8 +368,8 @@
PROXY_PRIMARY_THREAD_DESTRUCTOR()
BYPASS_PROXY_CONSTMETHOD0(webrtc::MediaType, media_type)
PROXY_CONSTMETHOD0(std::optional<std::string>, mid)
-PROXY_CONSTMETHOD0(rtc::scoped_refptr<RtpSenderInterface>, sender)
-PROXY_CONSTMETHOD0(rtc::scoped_refptr<RtpReceiverInterface>, receiver)
+PROXY_CONSTMETHOD0(scoped_refptr<RtpSenderInterface>, sender)
+PROXY_CONSTMETHOD0(scoped_refptr<RtpReceiverInterface>, receiver)
PROXY_CONSTMETHOD0(bool, stopped)
PROXY_CONSTMETHOD0(bool, stopping)
PROXY_CONSTMETHOD0(RtpTransceiverDirection, direction)
@@ -384,7 +378,7 @@
PROXY_CONSTMETHOD0(std::optional<RtpTransceiverDirection>, fired_direction)
PROXY_METHOD0(RTCError, StopStandard)
PROXY_METHOD0(void, StopInternal)
-PROXY_METHOD1(RTCError, SetCodecPreferences, rtc::ArrayView<RtpCodecCapability>)
+PROXY_METHOD1(RTCError, SetCodecPreferences, ArrayView<RtpCodecCapability>)
PROXY_CONSTMETHOD0(std::vector<RtpCodecCapability>, codec_preferences)
PROXY_CONSTMETHOD0(std::vector<RtpHeaderExtensionCapability>,
GetHeaderExtensionsToNegotiate)
@@ -392,7 +386,7 @@
GetNegotiatedHeaderExtensions)
PROXY_METHOD1(RTCError,
SetHeaderExtensionsToNegotiate,
- rtc::ArrayView<const RtpHeaderExtensionCapability>)
+ ArrayView<const RtpHeaderExtensionCapability>)
END_PROXY_MAP(RtpTransceiver)
} // namespace webrtc
diff --git a/pc/rtp_transceiver_unittest.cc b/pc/rtp_transceiver_unittest.cc
index b2f3590..c9b42be 100644
--- a/pc/rtp_transceiver_unittest.cc
+++ b/pc/rtp_transceiver_unittest.cc
@@ -98,14 +98,14 @@
}
PeerConnectionFactoryDependencies dependencies_;
- rtc::scoped_refptr<ConnectionContext> context_;
+ scoped_refptr<ConnectionContext> context_;
FakeCodecLookupHelper codec_lookup_helper_;
};
// Checks that a channel cannot be set on a stopped `RtpTransceiver`.
TEST_F(RtpTransceiverTest, CannotSetChannelOnStoppedTransceiver) {
const std::string content_name("my_mid");
- auto transceiver = rtc::make_ref_counted<RtpTransceiver>(
+ auto transceiver = make_ref_counted<RtpTransceiver>(
webrtc::MediaType::AUDIO, context(), codec_lookup_helper());
auto channel1 = std::make_unique<NiceMock<MockChannelInterface>>();
EXPECT_CALL(*channel1, media_type())
@@ -141,7 +141,7 @@
// Checks that a channel can be unset on a stopped `RtpTransceiver`
TEST_F(RtpTransceiverTest, CanUnsetChannelOnStoppedTransceiver) {
const std::string content_name("my_mid");
- auto transceiver = rtc::make_ref_counted<RtpTransceiver>(
+ auto transceiver = make_ref_counted<RtpTransceiver>(
webrtc::MediaType::VIDEO, context(), codec_lookup_helper());
auto channel = std::make_unique<NiceMock<MockChannelInterface>>();
EXPECT_CALL(*channel, media_type())
@@ -169,25 +169,25 @@
class RtpTransceiverUnifiedPlanTest : public RtpTransceiverTest {
public:
- static rtc::scoped_refptr<MockRtpReceiverInternal> MockReceiver(
+ static scoped_refptr<MockRtpReceiverInternal> MockReceiver(
webrtc::MediaType media_type) {
- auto receiver = rtc::make_ref_counted<NiceMock<MockRtpReceiverInternal>>();
+ auto receiver = make_ref_counted<NiceMock<MockRtpReceiverInternal>>();
EXPECT_CALL(*receiver.get(), media_type())
.WillRepeatedly(Return(media_type));
return receiver;
}
- static rtc::scoped_refptr<MockRtpSenderInternal> MockSender(
+ static scoped_refptr<MockRtpSenderInternal> MockSender(
webrtc::MediaType media_type) {
- auto sender = rtc::make_ref_counted<NiceMock<MockRtpSenderInternal>>();
+ auto sender = make_ref_counted<NiceMock<MockRtpSenderInternal>>();
EXPECT_CALL(*sender.get(), media_type()).WillRepeatedly(Return(media_type));
return sender;
}
- rtc::scoped_refptr<RtpTransceiver> CreateTransceiver(
- rtc::scoped_refptr<RtpSenderInternal> sender,
- rtc::scoped_refptr<RtpReceiverInternal> receiver) {
- return rtc::make_ref_counted<RtpTransceiver>(
+ scoped_refptr<RtpTransceiver> CreateTransceiver(
+ scoped_refptr<RtpSenderInternal> sender,
+ scoped_refptr<RtpReceiverInternal> receiver) {
+ return make_ref_counted<RtpTransceiver>(
RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
Thread::Current(), std::move(sender)),
RtpReceiverProxyWithInternal<RtpReceiverInternal>::Create(
@@ -203,11 +203,11 @@
// Basic tests for Stop()
TEST_F(RtpTransceiverUnifiedPlanTest, StopSetsDirection) {
- rtc::scoped_refptr<MockRtpReceiverInternal> receiver =
+ scoped_refptr<MockRtpReceiverInternal> receiver =
MockReceiver(webrtc::MediaType::AUDIO);
- rtc::scoped_refptr<MockRtpSenderInternal> sender =
+ scoped_refptr<MockRtpSenderInternal> sender =
MockSender(webrtc::MediaType::AUDIO);
- rtc::scoped_refptr<RtpTransceiver> transceiver =
+ scoped_refptr<RtpTransceiver> transceiver =
CreateTransceiver(sender, receiver);
EXPECT_CALL(*receiver.get(), Stop());
@@ -350,7 +350,7 @@
#endif // RTC_ENABLE_H265
protected:
- rtc::scoped_refptr<RtpTransceiver> transceiver_;
+ scoped_refptr<RtpTransceiver> transceiver_;
};
TEST_F(RtpTransceiverFilteredCodecPreferencesTest, EmptyByDefault) {
@@ -577,7 +577,7 @@
RtpHeaderExtensionCapability(RtpExtension::kVideoRotationUri,
4,
RtpTransceiverDirection::kSendRecv)}),
- transceiver_(rtc::make_ref_counted<RtpTransceiver>(
+ transceiver_(make_ref_counted<RtpTransceiver>(
RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
Thread::Current(),
sender_),
@@ -595,13 +595,13 @@
transceiver_->ClearChannel();
}
- rtc::scoped_refptr<MockRtpReceiverInternal> receiver_ =
+ scoped_refptr<MockRtpReceiverInternal> receiver_ =
MockReceiver(webrtc::MediaType::AUDIO);
- rtc::scoped_refptr<MockRtpSenderInternal> sender_ =
+ scoped_refptr<MockRtpSenderInternal> sender_ =
MockSender(webrtc::MediaType::AUDIO);
std::vector<RtpHeaderExtensionCapability> extensions_;
- rtc::scoped_refptr<RtpTransceiver> transceiver_;
+ scoped_refptr<RtpTransceiver> transceiver_;
};
TEST_F(RtpTransceiverTestForHeaderExtensions, OffersChannelManagerList) {
@@ -783,8 +783,8 @@
EXPECT_CALL(*mock_channel, mid()).WillRepeatedly(ReturnRef(content_name));
EXPECT_CALL(*mock_channel, SetRtpTransport(_)).WillRepeatedly(Return(true));
- cricket::RtpHeaderExtensions extensions = {RtpExtension("uri1", 1),
- RtpExtension("uri2", 2)};
+ RtpHeaderExtensions extensions = {RtpExtension("uri1", 1),
+ RtpExtension("uri2", 2)};
AudioContentDescription description;
description.set_rtp_header_extensions(extensions);
transceiver_->OnNegotiationUpdate(SdpType::kAnswer, &description);
@@ -812,8 +812,8 @@
EXPECT_CALL(*sender_.get(), SetTransceiverAsStopped());
EXPECT_CALL(*sender_.get(), Stop());
- cricket::RtpHeaderExtensions extensions = {RtpExtension("uri1", 1),
- RtpExtension("uri2", 2)};
+ RtpHeaderExtensions extensions = {RtpExtension("uri1", 1),
+ RtpExtension("uri2", 2)};
AudioContentDescription description;
description.set_rtp_header_extensions(extensions);
transceiver_->OnNegotiationUpdate(SdpType::kAnswer, &description);
@@ -852,8 +852,8 @@
};
// Default is stopped.
- auto sender = rtc::make_ref_counted<NiceMock<MockRtpSenderInternal>>();
- auto transceiver = rtc::make_ref_counted<RtpTransceiver>(
+ auto sender = make_ref_counted<NiceMock<MockRtpSenderInternal>>();
+ auto transceiver = make_ref_counted<RtpTransceiver>(
RtpSenderProxyWithInternal<RtpSenderInternal>::Create(Thread::Current(),
sender),
RtpReceiverProxyWithInternal<RtpReceiverInternal>::Create(
@@ -871,11 +871,10 @@
// Simulcast, i.e. more than one encoding.
RtpParameters simulcast_parameters;
simulcast_parameters.encodings.resize(2);
- auto simulcast_sender =
- rtc::make_ref_counted<NiceMock<MockRtpSenderInternal>>();
+ auto simulcast_sender = make_ref_counted<NiceMock<MockRtpSenderInternal>>();
EXPECT_CALL(*simulcast_sender, GetParametersInternal())
.WillRepeatedly(Return(simulcast_parameters));
- auto simulcast_transceiver = rtc::make_ref_counted<RtpTransceiver>(
+ auto simulcast_transceiver = make_ref_counted<RtpTransceiver>(
RtpSenderProxyWithInternal<RtpSenderInternal>::Create(Thread::Current(),
simulcast_sender),
RtpReceiverProxyWithInternal<RtpReceiverInternal>::Create(
@@ -899,10 +898,10 @@
svc_parameters.encodings.resize(1);
svc_parameters.encodings[0].scalability_mode = "L3T3";
- auto svc_sender = rtc::make_ref_counted<NiceMock<MockRtpSenderInternal>>();
+ auto svc_sender = make_ref_counted<NiceMock<MockRtpSenderInternal>>();
EXPECT_CALL(*svc_sender, GetParametersInternal())
.WillRepeatedly(Return(svc_parameters));
- auto svc_transceiver = rtc::make_ref_counted<RtpTransceiver>(
+ auto svc_transceiver = make_ref_counted<RtpTransceiver>(
RtpSenderProxyWithInternal<RtpSenderInternal>::Create(Thread::Current(),
svc_sender),
RtpReceiverProxyWithInternal<RtpReceiverInternal>::Create(
diff --git a/pc/rtp_transmission_manager.cc b/pc/rtp_transmission_manager.cc
index b6eac06..8c6d2a8 100644
--- a/pc/rtp_transmission_manager.cc
+++ b/pc/rtp_transmission_manager.cc
@@ -146,9 +146,8 @@
}
}
-RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>>
-RtpTransmissionManager::AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+RTCErrorOr<scoped_refptr<RtpSenderInterface>> RtpTransmissionManager::AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::vector<RtpEncodingParameters>* init_send_encodings) {
RTC_DCHECK_RUN_ON(signaling_thread());
@@ -158,9 +157,9 @@
: AddTrackPlanB(track, stream_ids, init_send_encodings));
}
-RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>>
+RTCErrorOr<scoped_refptr<RtpSenderInterface>>
RtpTransmissionManager::AddTrackPlanB(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::vector<RtpEncodingParameters>* init_send_encodings) {
RTC_DCHECK_RUN_ON(signaling_thread());
@@ -202,12 +201,12 @@
new_sender->internal()->SetSsrc(sender_info->first_ssrc);
}
}
- return rtc::scoped_refptr<RtpSenderInterface>(new_sender);
+ return scoped_refptr<RtpSenderInterface>(new_sender);
}
-RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>>
+RTCErrorOr<scoped_refptr<RtpSenderInterface>>
RtpTransmissionManager::AddTrackUnifiedPlan(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::vector<RtpEncodingParameters>* init_send_encodings) {
auto transceiver =
@@ -258,15 +257,15 @@
return transceiver->sender();
}
-rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>
+scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>
RtpTransmissionManager::CreateSender(
webrtc::MediaType media_type,
const std::string& id,
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::vector<RtpEncodingParameters>& send_encodings) {
RTC_DCHECK_RUN_ON(signaling_thread());
- rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender;
+ scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender;
if (media_type == webrtc::MediaType::AUDIO) {
RTC_DCHECK(!track ||
(track->kind() == MediaStreamTrackInterface::kAudioKind));
@@ -290,35 +289,33 @@
return sender;
}
-rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
+scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
RtpTransmissionManager::CreateReceiver(webrtc::MediaType media_type,
const std::string& receiver_id) {
RTC_DCHECK_RUN_ON(signaling_thread());
- rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
- receiver;
+ scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>> receiver;
if (media_type == webrtc::MediaType::AUDIO) {
receiver = RtpReceiverProxyWithInternal<RtpReceiverInternal>::Create(
signaling_thread(), worker_thread(),
- rtc::make_ref_counted<AudioRtpReceiver>(worker_thread(), receiver_id,
- std::vector<std::string>({}),
- IsUnifiedPlan()));
+ make_ref_counted<AudioRtpReceiver>(worker_thread(), receiver_id,
+ std::vector<std::string>({}),
+ IsUnifiedPlan()));
NoteUsageEvent(UsageEvent::AUDIO_ADDED);
} else {
RTC_DCHECK_EQ(media_type, webrtc::MediaType::VIDEO);
receiver = RtpReceiverProxyWithInternal<RtpReceiverInternal>::Create(
signaling_thread(), worker_thread(),
- rtc::make_ref_counted<VideoRtpReceiver>(worker_thread(), receiver_id,
- std::vector<std::string>({})));
+ make_ref_counted<VideoRtpReceiver>(worker_thread(), receiver_id,
+ std::vector<std::string>({})));
NoteUsageEvent(UsageEvent::VIDEO_ADDED);
}
return receiver;
}
-rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
RtpTransmissionManager::CreateAndAddTransceiver(
- rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender,
- rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
- receiver) {
+ scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender,
+ scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>> receiver) {
RTC_DCHECK_RUN_ON(signaling_thread());
// Ensure that the new sender does not have an ID that is already in use by
// another sender.
@@ -327,7 +324,7 @@
RTC_DCHECK(!FindSenderById(sender->id()));
auto transceiver = RtpTransceiverProxyWithInternal<RtpTransceiver>::Create(
signaling_thread(),
- rtc::make_ref_counted<RtpTransceiver>(
+ make_ref_counted<RtpTransceiver>(
sender, receiver, context_, codec_lookup_helper_,
sender->media_type() == webrtc::MediaType::AUDIO
? media_engine()->voice().GetRtpHeaderExtensions()
@@ -341,9 +338,9 @@
return transceiver;
}
-rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
RtpTransmissionManager::FindFirstTransceiverForAddedTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<RtpEncodingParameters>* init_send_encodings) {
RTC_DCHECK_RUN_ON(signaling_thread());
RTC_DCHECK(track);
@@ -361,10 +358,10 @@
return nullptr;
}
-std::vector<rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>>
+std::vector<scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>>
RtpTransmissionManager::GetSendersInternal() const {
RTC_DCHECK_RUN_ON(signaling_thread());
- std::vector<rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>>
+ std::vector<scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>>
all_senders;
for (const auto& transceiver : transceivers_.List()) {
if (IsUnifiedPlan() && transceiver->internal()->stopped())
@@ -376,12 +373,10 @@
return all_senders;
}
-std::vector<
- rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>>
+std::vector<scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>>
RtpTransmissionManager::GetReceiversInternal() const {
RTC_DCHECK_RUN_ON(signaling_thread());
- std::vector<
- rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>>
+ std::vector<scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>>
all_receivers;
for (const auto& transceiver : transceivers_.List()) {
if (IsUnifiedPlan() && transceiver->internal()->stopped())
@@ -394,7 +389,7 @@
return all_receivers;
}
-rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
RtpTransmissionManager::GetAudioTransceiver() const {
RTC_DCHECK_RUN_ON(signaling_thread());
// This method only works with Plan B SDP, where there is a single
@@ -409,7 +404,7 @@
return nullptr;
}
-rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
RtpTransmissionManager::GetVideoTransceiver() const {
RTC_DCHECK_RUN_ON(signaling_thread());
// This method only works with Plan B SDP, where there is a single
@@ -439,7 +434,7 @@
// Normal case; we've never seen this track before.
auto new_sender = CreateSender(webrtc::MediaType::AUDIO, track->id(),
- rtc::scoped_refptr<AudioTrackInterface>(track),
+ scoped_refptr<AudioTrackInterface>(track),
{stream->id()}, {{}});
new_sender->internal()->SetMediaChannel(voice_media_send_channel());
GetAudioTransceiver()->internal()->AddSender(new_sender);
@@ -486,7 +481,7 @@
// Normal case; we've never seen this track before.
auto new_sender = CreateSender(webrtc::MediaType::VIDEO, track->id(),
- rtc::scoped_refptr<VideoTrackInterface>(track),
+ scoped_refptr<VideoTrackInterface>(track),
{stream->id()}, {{}});
new_sender->internal()->SetMediaChannel(video_media_send_channel());
GetVideoTransceiver()->internal()->AddSender(new_sender);
@@ -514,11 +509,11 @@
MediaStreamInterface* stream,
const RtpSenderInfo& remote_sender_info) {
RTC_DCHECK(!closed_);
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams;
- streams.push_back(rtc::scoped_refptr<MediaStreamInterface>(stream));
+ std::vector<scoped_refptr<MediaStreamInterface>> streams;
+ streams.push_back(scoped_refptr<MediaStreamInterface>(stream));
// TODO(https://crbug.com/webrtc/9480): When we remove remote_streams(), use
// the constructor taking stream IDs instead.
- auto audio_receiver = rtc::make_ref_counted<AudioRtpReceiver>(
+ auto audio_receiver = make_ref_counted<AudioRtpReceiver>(
worker_thread(), remote_sender_info.sender_id, streams, IsUnifiedPlan(),
voice_media_receive_channel());
if (remote_sender_info.sender_id == kDefaultAudioSenderId) {
@@ -538,11 +533,11 @@
MediaStreamInterface* stream,
const RtpSenderInfo& remote_sender_info) {
RTC_DCHECK(!closed_);
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams;
- streams.push_back(rtc::scoped_refptr<MediaStreamInterface>(stream));
+ std::vector<scoped_refptr<MediaStreamInterface>> streams;
+ streams.push_back(scoped_refptr<MediaStreamInterface>(stream));
// TODO(https://crbug.com/webrtc/9480): When we remove remote_streams(), use
// the constructor taking stream IDs instead.
- auto video_receiver = rtc::make_ref_counted<VideoRtpReceiver>(
+ auto video_receiver = make_ref_counted<VideoRtpReceiver>(
worker_thread(), remote_sender_info.sender_id, streams);
video_receiver->SetupMediaChannel(
@@ -560,7 +555,7 @@
// TODO(deadbeef): Keep RtpReceivers around even if track goes away in remote
// description.
-rtc::scoped_refptr<RtpReceiverInterface>
+scoped_refptr<RtpReceiverInterface>
RtpTransmissionManager::RemoveAndStopReceiver(
const RtpSenderInfo& remote_sender_info) {
auto receiver = FindReceiverById(remote_sender_info.sender_id);
@@ -604,12 +599,12 @@
<< " receiver for track_id=" << sender_info.sender_id
<< " and stream_id=" << sender_info.stream_id;
- rtc::scoped_refptr<RtpReceiverInterface> receiver;
+ scoped_refptr<RtpReceiverInterface> receiver;
if (media_type == webrtc::MediaType::AUDIO) {
// When the MediaEngine audio channel is destroyed, the RemoteAudioSource
// will be notified which will end the AudioRtpReceiver::track().
receiver = RemoveAndStopReceiver(sender_info);
- rtc::scoped_refptr<AudioTrackInterface> audio_track =
+ scoped_refptr<AudioTrackInterface> audio_track =
stream->FindAudioTrack(sender_info.sender_id);
if (audio_track) {
stream->RemoveTrack(audio_track);
@@ -618,7 +613,7 @@
// Stopping or destroying a VideoRtpReceiver will end the
// VideoRtpReceiver::track().
receiver = RemoveAndStopReceiver(sender_info);
- rtc::scoped_refptr<VideoTrackInterface> video_track =
+ scoped_refptr<VideoTrackInterface> video_track =
stream->FindVideoTrack(sender_info.sender_id);
if (video_track) {
// There's no guarantee the track is still available, e.g. the track may
@@ -709,7 +704,7 @@
return nullptr;
}
-rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>
+scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>
RtpTransmissionManager::FindSenderForTrack(
MediaStreamTrackInterface* track) const {
RTC_DCHECK_RUN_ON(signaling_thread());
@@ -723,7 +718,7 @@
return nullptr;
}
-rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>
+scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>
RtpTransmissionManager::FindSenderById(const std::string& sender_id) const {
RTC_DCHECK_RUN_ON(signaling_thread());
for (const auto& transceiver : transceivers_.List()) {
@@ -736,7 +731,7 @@
return nullptr;
}
-rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
+scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
RtpTransmissionManager::FindReceiverById(const std::string& receiver_id) const {
RTC_DCHECK_RUN_ON(signaling_thread());
for (const auto& transceiver : transceivers_.List()) {
diff --git a/pc/rtp_transmission_manager.h b/pc/rtp_transmission_manager.h
index 6916675..6afb454 100644
--- a/pc/rtp_transmission_manager.h
+++ b/pc/rtp_transmission_manager.h
@@ -90,53 +90,52 @@
void OnSetStreams() override;
// Add a new track, creating transceiver if required.
- RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ RTCErrorOr<scoped_refptr<RtpSenderInterface>> AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::vector<RtpEncodingParameters>* init_send_encodings);
// Create a new RTP sender. Does not associate with a transceiver.
- rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>
- CreateSender(webrtc::MediaType media_type,
- const std::string& id,
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
- const std::vector<std::string>& stream_ids,
- const std::vector<RtpEncodingParameters>& send_encodings);
+ scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> CreateSender(
+ webrtc::MediaType media_type,
+ const std::string& id,
+ scoped_refptr<MediaStreamTrackInterface> track,
+ const std::vector<std::string>& stream_ids,
+ const std::vector<RtpEncodingParameters>& send_encodings);
// Create a new RTP receiver. Does not associate with a transceiver.
- rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
+ scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
CreateReceiver(webrtc::MediaType media_type, const std::string& receiver_id);
// Create a new RtpTransceiver of the given type and add it to the list of
// registered transceivers.
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+ scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
CreateAndAddTransceiver(
- rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender,
- rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
+ scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender,
+ scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
receiver);
// Returns the first RtpTransceiver suitable for a newly added track, if such
// transceiver is available.
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+ scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
FindFirstTransceiverForAddedTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<RtpEncodingParameters>* init_send_encodings);
// Returns the list of senders currently associated with some
// registered transceiver
- std::vector<rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>>
+ std::vector<scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>>
GetSendersInternal() const;
// Returns the list of receivers currently associated with a transceiver
- std::vector<
- rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>>
+ std::vector<scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>>
GetReceiversInternal() const;
// Plan B: Get the transceiver containing all audio senders and receivers
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+ scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
GetAudioTransceiver() const;
// Plan B: Get the transceiver containing all video senders and receivers
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+ scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
GetVideoTransceiver() const;
// Add an audio track, reusing or creating the sender.
@@ -188,15 +187,15 @@
const std::string& sender_id) const;
// Return the RtpSender with the given track attached.
- rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>
+ scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>
FindSenderForTrack(MediaStreamTrackInterface* track) const;
// Return the RtpSender with the given id, or null if none exists.
- rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>
- FindSenderById(const std::string& sender_id) const;
+ scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> FindSenderById(
+ const std::string& sender_id) const;
// Return the RtpReceiver with the given id, or null if none exists.
- rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
+ scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
FindReceiverById(const std::string& receiver_id) const;
TransceiverList* transceivers() { return &transceivers_; }
@@ -218,13 +217,13 @@
}
// AddTrack implementation when Unified Plan is specified.
- RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrackUnifiedPlan(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ RTCErrorOr<scoped_refptr<RtpSenderInterface>> AddTrackUnifiedPlan(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::vector<RtpEncodingParameters>* init_send_encodings);
// AddTrack implementation when Plan B is specified.
- RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrackPlanB(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ RTCErrorOr<scoped_refptr<RtpSenderInterface>> AddTrackPlanB(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::vector<RtpEncodingParameters>* init_send_encodings);
@@ -237,7 +236,7 @@
void CreateVideoReceiver(MediaStreamInterface* stream,
const RtpSenderInfo& remote_sender_info)
RTC_RUN_ON(signaling_thread());
- rtc::scoped_refptr<RtpReceiverInterface> RemoveAndStopReceiver(
+ scoped_refptr<RtpReceiverInterface> RemoveAndStopReceiver(
const RtpSenderInfo& remote_sender_info) RTC_RUN_ON(signaling_thread());
PeerConnectionObserver* Observer() const;
diff --git a/pc/rtp_transport.cc b/pc/rtp_transport.cc
index 96dc9d5..2ab4ef5 100644
--- a/pc/rtp_transport.cc
+++ b/pc/rtp_transport.cc
@@ -78,8 +78,8 @@
new_packet_transport->SignalReadyToSend.connect(
this, &RtpTransport::OnReadyToSend);
new_packet_transport->RegisterReceivedPacketCallback(
- this, [&](rtc::PacketTransportInternal* transport,
- const rtc::ReceivedPacket& packet) {
+ this, [&](PacketTransportInternal* transport,
+ const ReceivedIpPacket& packet) {
OnReadPacket(transport, packet);
});
new_packet_transport->SignalNetworkRouteChanged.connect(
@@ -115,8 +115,8 @@
new_packet_transport->SignalReadyToSend.connect(
this, &RtpTransport::OnReadyToSend);
new_packet_transport->RegisterReceivedPacketCallback(
- this, [&](rtc::PacketTransportInternal* transport,
- const rtc::ReceivedPacket& packet) {
+ this, [&](PacketTransportInternal* transport,
+ const ReceivedIpPacket& packet) {
OnReadPacket(transport, packet);
});
new_packet_transport->SignalNetworkRouteChanged.connect(
@@ -142,21 +142,21 @@
return transport && transport->writable();
}
-bool RtpTransport::SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options,
+bool RtpTransport::SendRtpPacket(CopyOnWriteBuffer* packet,
+ const AsyncSocketPacketOptions& options,
int flags) {
return SendPacket(false, packet, options, flags);
}
-bool RtpTransport::SendRtcpPacket(rtc::CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options,
+bool RtpTransport::SendRtcpPacket(CopyOnWriteBuffer* packet,
+ const AsyncSocketPacketOptions& options,
int flags) {
return SendPacket(true, packet, options, flags);
}
bool RtpTransport::SendPacket(bool rtcp,
- rtc::CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options,
+ CopyOnWriteBuffer* packet,
+ const AsyncSocketPacketOptions& options,
int flags) {
PacketTransportInternal* transport = rtcp && !rtcp_mux_enabled_
? rtcp_packet_transport_
@@ -178,7 +178,7 @@
}
void RtpTransport::UpdateRtpHeaderExtensionMap(
- const cricket::RtpHeaderExtensions& header_extensions) {
+ const RtpHeaderExtensions& header_extensions) {
header_extension_map_ = RtpHeaderExtensionMap(header_extensions);
}
@@ -204,9 +204,9 @@
return rtp_demuxer_.GetSsrcsForSink(sink);
}
-void RtpTransport::DemuxPacket(rtc::CopyOnWriteBuffer packet,
+void RtpTransport::DemuxPacket(CopyOnWriteBuffer packet,
webrtc::Timestamp arrival_time,
- rtc::EcnMarking ecn) {
+ EcnMarking ecn) {
RtpPacketReceived parsed_packet(&header_extension_map_);
parsed_packet.set_arrival_time(arrival_time);
parsed_packet.set_ecn(ecn);
@@ -247,7 +247,7 @@
}
void RtpTransport::OnSentPacket(PacketTransportInternal* packet_transport,
- const rtc::SentPacket& sent_packet) {
+ const SentPacketInfo& sent_packet) {
RTC_DCHECK(packet_transport == rtp_packet_transport_ ||
packet_transport == rtcp_packet_transport_);
if (processing_sent_packet_) {
@@ -261,8 +261,8 @@
}
void RtpTransport::OnRtpPacketReceived(
- const rtc::ReceivedPacket& received_packet) {
- rtc::CopyOnWriteBuffer payload(received_packet.payload());
+ const ReceivedIpPacket& received_packet) {
+ CopyOnWriteBuffer payload(received_packet.payload());
DemuxPacket(
payload,
received_packet.arrival_time().value_or(Timestamp::MinusInfinity()),
@@ -270,8 +270,8 @@
}
void RtpTransport::OnRtcpPacketReceived(
- const rtc::ReceivedPacket& received_packet) {
- rtc::CopyOnWriteBuffer payload(received_packet.payload());
+ const ReceivedIpPacket& received_packet) {
+ CopyOnWriteBuffer payload(received_packet.payload());
// TODO(bugs.webrtc.org/15368): Propagate timestamp and maybe received packet
// further.
SendRtcpPacketReceived(&payload, received_packet.arrival_time()
@@ -280,7 +280,7 @@
}
void RtpTransport::OnReadPacket(PacketTransportInternal* transport,
- const rtc::ReceivedPacket& received_packet) {
+ const ReceivedIpPacket& received_packet) {
TRACE_EVENT0("webrtc", "RtpTransport::OnReadPacket");
// When using RTCP multiplexing we might get RTCP packets on the RTP
diff --git a/pc/rtp_transport.h b/pc/rtp_transport.h
index a577cd5..4394b16 100644
--- a/pc/rtp_transport.h
+++ b/pc/rtp_transport.h
@@ -71,18 +71,18 @@
bool IsWritable(bool rtcp) const override;
- bool SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options,
+ bool SendRtpPacket(CopyOnWriteBuffer* packet,
+ const AsyncSocketPacketOptions& options,
int flags) override;
- bool SendRtcpPacket(rtc::CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options,
+ bool SendRtcpPacket(CopyOnWriteBuffer* packet,
+ const AsyncSocketPacketOptions& options,
int flags) override;
bool IsSrtpActive() const override { return false; }
void UpdateRtpHeaderExtensionMap(
- const cricket::RtpHeaderExtensions& header_extensions) override;
+ const RtpHeaderExtensions& header_extensions) override;
bool RegisterRtpDemuxerSink(const RtpDemuxerCriteria& criteria,
RtpPacketSinkInterface* sink) override;
@@ -91,29 +91,29 @@
protected:
// These methods will be used in the subclasses.
- void DemuxPacket(rtc::CopyOnWriteBuffer packet,
+ void DemuxPacket(CopyOnWriteBuffer packet,
Timestamp arrival_time,
- rtc::EcnMarking ecn);
+ EcnMarking ecn);
bool SendPacket(bool rtcp,
- rtc::CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options,
+ CopyOnWriteBuffer* packet,
+ const AsyncSocketPacketOptions& options,
int flags);
flat_set<uint32_t> GetSsrcsForSink(RtpPacketSinkInterface* sink);
// Overridden by SrtpTransport.
virtual void OnNetworkRouteChanged(std::optional<NetworkRoute> network_route);
- virtual void OnRtpPacketReceived(const rtc::ReceivedPacket& packet);
- virtual void OnRtcpPacketReceived(const rtc::ReceivedPacket& packet);
+ virtual void OnRtpPacketReceived(const ReceivedIpPacket& packet);
+ virtual void OnRtcpPacketReceived(const ReceivedIpPacket& packet);
// Overridden by SrtpTransport and DtlsSrtpTransport.
virtual void OnWritableState(PacketTransportInternal* packet_transport);
private:
void OnReadyToSend(PacketTransportInternal* transport);
void OnSentPacket(PacketTransportInternal* packet_transport,
- const rtc::SentPacket& sent_packet);
+ const SentPacketInfo& sent_packet);
void OnReadPacket(PacketTransportInternal* transport,
- const rtc::ReceivedPacket& received_packet);
+ const ReceivedIpPacket& received_packet);
// Updates "ready to send" for an individual channel and fires
// SignalReadyToSend.
diff --git a/pc/rtp_transport_internal.h b/pc/rtp_transport_internal.h
index addde97..faac226 100644
--- a/pc/rtp_transport_internal.h
+++ b/pc/rtp_transport_internal.h
@@ -66,7 +66,7 @@
// BaseChannel through the RtpDemuxer callback.
void SubscribeRtcpPacketReceived(
const void* tag,
- absl::AnyInvocable<void(rtc::CopyOnWriteBuffer*, int64_t)> callback) {
+ absl::AnyInvocable<void(webrtc::CopyOnWriteBuffer*, int64_t)> callback) {
callback_list_rtcp_packet_received_.AddReceiver(tag, std::move(callback));
}
// There doesn't seem to be a need to unsubscribe from this signal.
@@ -100,7 +100,7 @@
}
void SubscribeSentPacket(
const void* tag,
- absl::AnyInvocable<void(const rtc::SentPacket&)> callback) {
+ absl::AnyInvocable<void(const webrtc::SentPacketInfo&)> callback) {
callback_list_sent_packet_.AddReceiver(tag, std::move(callback));
}
void UnsubscribeSentPacket(const void* tag) {
@@ -111,12 +111,12 @@
// TODO(zhihuang): Pass the `packet` by copy so that the original data
// wouldn't be modified.
- virtual bool SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options,
+ virtual bool SendRtpPacket(CopyOnWriteBuffer* packet,
+ const AsyncSocketPacketOptions& options,
int flags) = 0;
- virtual bool SendRtcpPacket(rtc::CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options,
+ virtual bool SendRtcpPacket(CopyOnWriteBuffer* packet,
+ const AsyncSocketPacketOptions& options,
int flags) = 0;
// This method updates the RTP header extension map so that the RTP transport
@@ -130,7 +130,7 @@
// UpdateRecvEncryptedHeaderExtensionIds,
// CacheRtpAbsSendTimeHeaderExtension,
virtual void UpdateRtpHeaderExtensionMap(
- const cricket::RtpHeaderExtensions& header_extensions) = 0;
+ const RtpHeaderExtensions& header_extensions) = 0;
virtual bool IsSrtpActive() const = 0;
@@ -141,7 +141,7 @@
protected:
void SendReadyToSend(bool arg) { callback_list_ready_to_send_.Send(arg); }
- void SendRtcpPacketReceived(rtc::CopyOnWriteBuffer* buffer,
+ void SendRtcpPacketReceived(CopyOnWriteBuffer* buffer,
int64_t packet_time_us) {
callback_list_rtcp_packet_received_.Send(buffer, packet_time_us);
}
@@ -154,21 +154,20 @@
void SendWritableState(bool state) {
callback_list_writable_state_.Send(state);
}
- void SendSentPacket(const rtc::SentPacket& packet) {
+ void SendSentPacket(const SentPacketInfo& packet) {
callback_list_sent_packet_.Send(packet);
}
private:
CallbackList<bool> callback_list_ready_to_send_;
- CallbackList<rtc::CopyOnWriteBuffer*, int64_t>
- callback_list_rtcp_packet_received_;
+ CallbackList<CopyOnWriteBuffer*, int64_t> callback_list_rtcp_packet_received_;
absl::AnyInvocable<void(RtpPacketReceived&)>
callback_undemuxable_rtp_packet_received_ =
[](RtpPacketReceived& packet) {};
CallbackList<std::optional<NetworkRoute>>
callback_list_network_route_changed_;
CallbackList<bool> callback_list_writable_state_;
- CallbackList<const rtc::SentPacket&> callback_list_sent_packet_;
+ CallbackList<const SentPacketInfo&> callback_list_sent_packet_;
};
} // namespace webrtc
diff --git a/pc/rtp_transport_unittest.cc b/pc/rtp_transport_unittest.cc
index e2babb3..c4d207d 100644
--- a/pc/rtp_transport_unittest.cc
+++ b/pc/rtp_transport_unittest.cc
@@ -51,7 +51,7 @@
transport->SubscribeReadyToSend(
this, [this](bool ready) { OnReadyToSend(ready); });
transport->SubscribeNetworkRouteChanged(
- this, [this](std::optional<rtc::NetworkRoute> route) {
+ this, [this](std::optional<NetworkRoute> route) {
OnNetworkRouteChanged(route);
});
if (transport->rtp_packet_transport()) {
@@ -74,7 +74,7 @@
}
void OnSentPacket(PacketTransportInternal* packet_transport,
- const rtc::SentPacket& sent_packet) {
+ const SentPacketInfo& sent_packet) {
if (packet_transport == transport_->rtp_packet_transport()) {
rtp_transport_sent_count_++;
} else {
@@ -234,14 +234,14 @@
fake_rtp.SetDestination(&fake_rtp, true);
fake_rtcp.SetDestination(&fake_rtcp, true);
- rtc::CopyOnWriteBuffer packet;
- EXPECT_TRUE(transport.SendRtcpPacket(&packet, rtc::PacketOptions(), 0));
+ CopyOnWriteBuffer packet;
+ EXPECT_TRUE(transport.SendRtcpPacket(&packet, AsyncSocketPacketOptions(), 0));
EXPECT_EQ(1, observer.rtcp_transport_sent_count());
// The RTCP packets are expected to be sent over RtpPacketTransport if
// RTCP-mux is enabled.
transport.SetRtcpMuxEnabled(true);
- EXPECT_TRUE(transport.SendRtcpPacket(&packet, rtc::PacketOptions(), 0));
+ EXPECT_TRUE(transport.SendRtcpPacket(&packet, AsyncSocketPacketOptions(), 0));
EXPECT_EQ(1, observer.rtp_transport_sent_count());
}
@@ -280,7 +280,7 @@
// An rtcp packet.
const unsigned char data[] = {0x80, 73, 0, 0};
const int len = 4;
- const rtc::PacketOptions options;
+ const AsyncSocketPacketOptions options;
const int flags = 0;
fake_rtp.SendPacket(reinterpret_cast<const char*>(data), len, options, flags);
EXPECT_EQ(0, observer.rtp_count());
@@ -305,9 +305,9 @@
transport.RegisterRtpDemuxerSink(demuxer_criteria, &observer);
// An rtp packet.
- const rtc::PacketOptions options;
+ const AsyncSocketPacketOptions options;
const int flags = 0;
- rtc::Buffer rtp_data(kRtpData, kRtpLen);
+ Buffer rtp_data(kRtpData, kRtpLen);
fake_rtp.SendPacket(rtp_data.data<char>(), kRtpLen, options, flags);
EXPECT_EQ(1, observer.rtp_count());
EXPECT_EQ(0, observer.un_demuxable_rtp_count());
@@ -328,13 +328,13 @@
demuxer_criteria.payload_types().insert(0x11);
transport.RegisterRtpDemuxerSink(demuxer_criteria, &observer);
- rtc::PacketOptions options;
+ AsyncSocketPacketOptions options;
options.ecn_1 = true;
const int flags = 0;
- rtc::Buffer rtp_data(kRtpData, kRtpLen);
+ Buffer rtp_data(kRtpData, kRtpLen);
fake_rtp.SendPacket(rtp_data.data<char>(), kRtpLen, options, flags);
ASSERT_EQ(observer.rtp_count(), 1);
- EXPECT_EQ(observer.last_recv_rtp_packet().ecn(), rtc::EcnMarking::kEct1);
+ EXPECT_EQ(observer.last_recv_rtp_packet().ecn(), EcnMarking::kEct1);
transport.UnregisterRtpDemuxerSink(&observer);
}
@@ -352,9 +352,9 @@
demuxer_criteria.payload_types().insert(0x12);
transport.RegisterRtpDemuxerSink(demuxer_criteria, &observer);
- const rtc::PacketOptions options;
+ const AsyncSocketPacketOptions options;
const int flags = 0;
- rtc::Buffer rtp_data(kRtpData, kRtpLen);
+ Buffer rtp_data(kRtpData, kRtpLen);
fake_rtp.SendPacket(rtp_data.data<char>(), kRtpLen, options, flags);
EXPECT_EQ(0, observer.rtp_count());
EXPECT_EQ(1, observer.un_demuxable_rtp_count());
@@ -375,12 +375,12 @@
fake_rtp.SetWritable(true);
EXPECT_TRUE(observer.ready_to_send());
EXPECT_EQ(observer.ready_to_send_signal_count(), 1);
- rtc::CopyOnWriteBuffer packet;
- EXPECT_TRUE(transport.SendRtpPacket(&packet, rtc::PacketOptions(), 0));
+ CopyOnWriteBuffer packet;
+ EXPECT_TRUE(transport.SendRtpPacket(&packet, AsyncSocketPacketOptions(), 0));
// The fake RTP will return -1 due to ENOTCONN.
fake_rtp.SetError(ENOTCONN);
- EXPECT_FALSE(transport.SendRtpPacket(&packet, rtc::PacketOptions(), 0));
+ EXPECT_FALSE(transport.SendRtpPacket(&packet, AsyncSocketPacketOptions(), 0));
// Ready to send state should not have changed.
EXPECT_TRUE(observer.ready_to_send());
EXPECT_EQ(observer.ready_to_send_signal_count(), 1);
@@ -397,9 +397,9 @@
transport.SetRtpPacketTransport(&fake_rtp);
TransportObserver observer(&transport);
observer.SetActionOnReadyToSend([&](bool ready) {
- const rtc::PacketOptions options;
+ const AsyncSocketPacketOptions options;
const int flags = 0;
- rtc::CopyOnWriteBuffer rtp_data(kRtpData, kRtpLen);
+ CopyOnWriteBuffer rtp_data(kRtpData, kRtpLen);
transport.SendRtpPacket(&rtp_data, options, flags);
});
// The fake RTP will have no destination, so will return -1.
@@ -424,17 +424,17 @@
transport.SetRtpPacketTransport(&fake_rtp);
fake_rtp.SetDestination(&fake_rtp, true);
TransportObserver observer(&transport);
- const rtc::PacketOptions options;
+ const AsyncSocketPacketOptions options;
const int flags = 0;
fake_rtp.SetWritable(true);
observer.SetActionOnSentPacket([&]() {
- rtc::CopyOnWriteBuffer rtp_data(kRtpData, kRtpLen);
+ CopyOnWriteBuffer rtp_data(kRtpData, kRtpLen);
if (observer.sent_packet_count() < 2) {
transport.SendRtpPacket(&rtp_data, options, flags);
}
});
- rtc::CopyOnWriteBuffer rtp_data(kRtpData, kRtpLen);
+ CopyOnWriteBuffer rtp_data(kRtpData, kRtpLen);
transport.SendRtpPacket(&rtp_data, options, flags);
EXPECT_EQ(observer.sent_packet_count(), 1);
EXPECT_THAT(
diff --git a/pc/scenario_tests/goog_cc_test.cc b/pc/scenario_tests/goog_cc_test.cc
index 2fb58aa..2e8ff64 100644
--- a/pc/scenario_tests/goog_cc_test.cc
+++ b/pc/scenario_tests/goog_cc_test.cc
@@ -74,8 +74,7 @@
ASSERT_EQ(num_video_streams, 1); // Exactly 1 video stream.
auto get_bwe = [&] {
- auto callback =
- rtc::make_ref_counted<webrtc::MockRTCStatsCollectorCallback>();
+ auto callback = make_ref_counted<webrtc::MockRTCStatsCollectorCallback>();
caller->pc()->GetStats(callback.get());
s.net()->time_controller()->Wait([&] { return callback->called(); });
auto stats =
diff --git a/pc/sctp_data_channel.cc b/pc/sctp_data_channel.cc
index cbfbfd7..0faa6bb 100644
--- a/pc/sctp_data_channel.cc
+++ b/pc/sctp_data_channel.cc
@@ -178,7 +178,7 @@
public:
explicit ObserverAdapter(
SctpDataChannel* channel,
- rtc::scoped_refptr<PendingTaskSafetyFlag> signaling_safety)
+ scoped_refptr<PendingTaskSafetyFlag> signaling_safety)
: channel_(channel), signaling_safety_(std::move(signaling_safety)) {}
bool IsInsideCallback() const {
@@ -291,12 +291,12 @@
// `channel_` in the `RTC_DCHECK_RUN_ON` checks on the signaling thread.
Thread* const signaling_thread_{channel_->signaling_thread_};
ScopedTaskSafety safety_;
- rtc::scoped_refptr<PendingTaskSafetyFlag> signaling_safety_;
+ scoped_refptr<PendingTaskSafetyFlag> signaling_safety_;
CachedGetters* cached_getters_ RTC_GUARDED_BY(signaling_thread()) = nullptr;
};
// static
-rtc::scoped_refptr<SctpDataChannel> SctpDataChannel::Create(
+scoped_refptr<SctpDataChannel> SctpDataChannel::Create(
WeakPtr<SctpDataChannelControllerInterface> controller,
const std::string& label,
bool connected_to_transport,
@@ -304,15 +304,15 @@
Thread* signaling_thread,
Thread* network_thread) {
RTC_DCHECK(config.IsValid());
- return rtc::make_ref_counted<SctpDataChannel>(
- config, std::move(controller), label, connected_to_transport,
- signaling_thread, network_thread);
+ return make_ref_counted<SctpDataChannel>(config, std::move(controller), label,
+ connected_to_transport,
+ signaling_thread, network_thread);
}
// static
-rtc::scoped_refptr<DataChannelInterface> SctpDataChannel::CreateProxy(
- rtc::scoped_refptr<SctpDataChannel> channel,
- rtc::scoped_refptr<PendingTaskSafetyFlag> signaling_safety) {
+scoped_refptr<DataChannelInterface> SctpDataChannel::CreateProxy(
+ scoped_refptr<SctpDataChannel> channel,
+ scoped_refptr<PendingTaskSafetyFlag> signaling_safety) {
// Copy thread params to local variables before `std::move()`.
auto* signaling_thread = channel->signaling_thread_;
auto* network_thread = channel->network_thread_;
@@ -401,7 +401,7 @@
// a reference to ourselves while the task is in flight. We can't use
// `SafeTask(network_safety_, ...)` for this since we can't assume that we
// have a transport (network_safety_ represents the transport connection).
- rtc::scoped_refptr<SctpDataChannel> me(this);
+ scoped_refptr<SctpDataChannel> me(this);
auto register_observer = [me = std::move(me), observer = observer] {
RTC_DCHECK_RUN_ON(me->network_thread_);
me->observer_ = observer;
@@ -688,7 +688,7 @@
}
void SctpDataChannel::OnDataReceived(DataMessageType type,
- const rtc::CopyOnWriteBuffer& payload) {
+ const CopyOnWriteBuffer& payload) {
RTC_DCHECK_RUN_ON(network_thread_);
RTC_DCHECK(id_n_.has_value());
@@ -790,13 +790,13 @@
case kConnecting: {
if (connected_to_transport() && controller_) {
if (handshake_state_ == kHandshakeShouldSendOpen) {
- rtc::CopyOnWriteBuffer payload;
+ CopyOnWriteBuffer payload;
WriteDataChannelOpenMessage(label_, protocol_, priority_, ordered_,
max_retransmits_, max_retransmit_time_,
&payload);
SendControlMessage(payload);
} else if (handshake_state_ == kHandshakeShouldSendAck) {
- rtc::CopyOnWriteBuffer payload;
+ CopyOnWriteBuffer payload;
WriteDataChannelOpenAckMessage(&payload);
SendControlMessage(payload);
}
@@ -959,7 +959,7 @@
}
// RTC_RUN_ON(network_thread_).
-bool SctpDataChannel::SendControlMessage(const rtc::CopyOnWriteBuffer& buffer) {
+bool SctpDataChannel::SendControlMessage(const CopyOnWriteBuffer& buffer) {
RTC_DCHECK(connected_to_transport());
RTC_DCHECK(id_n_.has_value());
RTC_DCHECK(controller_);
diff --git a/pc/sctp_data_channel.h b/pc/sctp_data_channel.h
index de3c2b9..71ccd2c 100644
--- a/pc/sctp_data_channel.h
+++ b/pc/sctp_data_channel.h
@@ -46,7 +46,7 @@
// Sends the data to the transport.
virtual RTCError SendData(StreamId sid,
const SendDataParams& params,
- const rtc::CopyOnWriteBuffer& payload) = 0;
+ const CopyOnWriteBuffer& payload) = 0;
// Adds the data channel SID to the transport for SCTP.
virtual void AddSctpDataStream(StreamId sid, PriorityValue priority) = 0;
// Begins the closing procedure by sending an outgoing stream reset. Still
@@ -129,7 +129,7 @@
// OnClosingProcedureComplete callback and transition to kClosed.
class SctpDataChannel : public DataChannelInterface {
public:
- static rtc::scoped_refptr<SctpDataChannel> Create(
+ static scoped_refptr<SctpDataChannel> Create(
WeakPtr<SctpDataChannelControllerInterface> controller,
const std::string& label,
bool connected_to_transport,
@@ -144,9 +144,9 @@
// callbacks after the peerconnection has been closed. The data controller
// will update the flag when closed, which will cancel any pending event
// notifications.
- static rtc::scoped_refptr<DataChannelInterface> CreateProxy(
- rtc::scoped_refptr<SctpDataChannel> channel,
- rtc::scoped_refptr<PendingTaskSafetyFlag> signaling_safety);
+ static scoped_refptr<DataChannelInterface> CreateProxy(
+ scoped_refptr<SctpDataChannel> channel,
+ scoped_refptr<PendingTaskSafetyFlag> signaling_safety);
void RegisterObserver(DataChannelObserver* observer) override;
void UnregisterObserver() override;
@@ -186,8 +186,7 @@
// already finished.
void OnTransportReady();
- void OnDataReceived(DataMessageType type,
- const rtc::CopyOnWriteBuffer& payload);
+ void OnDataReceived(DataMessageType type, const CopyOnWriteBuffer& payload);
// Sets the SCTP sid and adds to transport layer if not set yet. Should only
// be called once.
@@ -256,7 +255,7 @@
RTCError SendDataMessage(const DataBuffer& buffer, bool queue_if_blocked)
RTC_RUN_ON(network_thread_);
- bool SendControlMessage(const rtc::CopyOnWriteBuffer& buffer)
+ bool SendControlMessage(const CopyOnWriteBuffer& buffer)
RTC_RUN_ON(network_thread_);
bool connected_to_transport() const RTC_RUN_ON(network_thread_) {
@@ -293,7 +292,7 @@
// Did we already start the graceful SCTP closing procedure?
bool started_closing_procedure_ RTC_GUARDED_BY(network_thread_) = false;
PacketQueue queued_received_data_ RTC_GUARDED_BY(network_thread_);
- rtc::scoped_refptr<PendingTaskSafetyFlag> network_safety_ =
+ scoped_refptr<PendingTaskSafetyFlag> network_safety_ =
PendingTaskSafetyFlag::CreateDetachedInactive();
};
diff --git a/pc/sctp_transport.cc b/pc/sctp_transport.cc
index f09c380..6f56026 100644
--- a/pc/sctp_transport.cc
+++ b/pc/sctp_transport.cc
@@ -34,7 +34,7 @@
namespace webrtc {
SctpTransport::SctpTransport(std::unique_ptr<SctpTransportInternal> internal,
- rtc::scoped_refptr<DtlsTransport> dtls_transport)
+ scoped_refptr<DtlsTransport> dtls_transport)
: owner_thread_(Thread::Current()),
info_(SctpTransportState::kConnecting,
dtls_transport,
@@ -46,8 +46,7 @@
RTC_DCHECK(dtls_transport_.get());
dtls_transport_->internal()->SubscribeDtlsTransportState(
- [this](cricket::DtlsTransportInternal* transport,
- DtlsTransportState state) {
+ [this](DtlsTransportInternal* transport, DtlsTransportState state) {
OnDtlsStateChange(transport, state);
});
@@ -95,7 +94,7 @@
RTCError SctpTransport::SendData(int channel_id,
const SendDataParams& params,
- const rtc::CopyOnWriteBuffer& buffer) {
+ const CopyOnWriteBuffer& buffer) {
RTC_DCHECK_RUN_ON(owner_thread_);
return internal_sctp_transport_->SendData(channel_id, params, buffer);
}
@@ -136,8 +135,7 @@
internal_sctp_transport_->SetBufferedAmountLowThreshold(channel_id, bytes);
}
-rtc::scoped_refptr<DtlsTransportInterface> SctpTransport::dtls_transport()
- const {
+scoped_refptr<DtlsTransportInterface> SctpTransport::dtls_transport() const {
RTC_DCHECK_RUN_ON(owner_thread_);
return dtls_transport_;
}
diff --git a/pc/sctp_transport.h b/pc/sctp_transport.h
index ca275ec..cc43aaa 100644
--- a/pc/sctp_transport.h
+++ b/pc/sctp_transport.h
@@ -30,19 +30,19 @@
namespace webrtc {
-// This implementation wraps a cricket::SctpTransport, and takes
+// This implementation wraps a webrtc::SctpTransport, and takes
// ownership of it.
// This object must be constructed and updated on the networking thread,
-// the same thread as the one the cricket::SctpTransportInternal object
+// the same thread as the one the webrtc::SctpTransportInternal object
// lives on.
class SctpTransport : public SctpTransportInterface,
public DataChannelTransportInterface {
public:
SctpTransport(std::unique_ptr<SctpTransportInternal> internal,
- rtc::scoped_refptr<DtlsTransport> dtls_transport);
+ scoped_refptr<DtlsTransport> dtls_transport);
// SctpTransportInterface
- rtc::scoped_refptr<DtlsTransportInterface> dtls_transport() const override;
+ scoped_refptr<DtlsTransportInterface> dtls_transport() const override;
SctpTransportInformation Information() const override;
void RegisterObserver(SctpTransportObserverInterface* observer) override;
void UnregisterObserver() override;
@@ -51,7 +51,7 @@
RTCError OpenChannel(int channel_id, PriorityValue priority) override;
RTCError SendData(int channel_id,
const SendDataParams& params,
- const rtc::CopyOnWriteBuffer& buffer) override;
+ const CopyOnWriteBuffer& buffer) override;
RTCError CloseChannel(int channel_id) override;
void SetDataSink(DataChannelSink* sink) override;
bool IsReadyToSend() const override;
@@ -61,7 +61,7 @@
// Internal functions
void Clear();
- // Initialize the cricket::SctpTransport. This can be called from
+ // Initialize the webrtc::SctpTransport. This can be called from
// the signaling thread.
void Start(const SctpOptions& options);
@@ -98,8 +98,7 @@
RTC_GUARDED_BY(owner_thread_);
SctpTransportObserverInterface* observer_ RTC_GUARDED_BY(owner_thread_) =
nullptr;
- rtc::scoped_refptr<DtlsTransport> dtls_transport_
- RTC_GUARDED_BY(owner_thread_);
+ scoped_refptr<DtlsTransport> dtls_transport_ RTC_GUARDED_BY(owner_thread_);
};
} // namespace webrtc
diff --git a/pc/sctp_transport_unittest.cc b/pc/sctp_transport_unittest.cc
index d494f75..c47690c 100644
--- a/pc/sctp_transport_unittest.cc
+++ b/pc/sctp_transport_unittest.cc
@@ -57,7 +57,7 @@
bool ResetStream(int sid) override { return true; }
RTCError SendData(int sid,
const SendDataParams& params,
- const rtc::CopyOnWriteBuffer& payload) override {
+ const CopyOnWriteBuffer& payload) override {
return RTCError::OK();
}
bool ReadyToSendData() override { return true; }
@@ -127,11 +127,11 @@
std::make_unique<FakeDtlsTransport>("audio",
ICE_CANDIDATE_COMPONENT_RTP);
dtls_transport_ =
- rtc::make_ref_counted<DtlsTransport>(std::move(cricket_transport));
+ make_ref_counted<DtlsTransport>(std::move(cricket_transport));
auto cricket_sctp_transport =
absl::WrapUnique(new FakeCricketSctpTransport());
- transport_ = rtc::make_ref_counted<SctpTransport>(
+ transport_ = make_ref_counted<SctpTransport>(
std::move(cricket_sctp_transport), dtls_transport_);
}
@@ -148,8 +148,8 @@
}
AutoThread main_thread_;
- rtc::scoped_refptr<SctpTransport> transport_;
- rtc::scoped_refptr<DtlsTransport> dtls_transport_;
+ scoped_refptr<SctpTransport> transport_;
+ scoped_refptr<DtlsTransport> dtls_transport_;
TestSctpTransportObserver observer_;
};
@@ -157,14 +157,13 @@
AutoThread main_thread;
std::unique_ptr<DtlsTransportInternal> cricket_transport =
std::make_unique<FakeDtlsTransport>("audio", ICE_CANDIDATE_COMPONENT_RTP);
- rtc::scoped_refptr<DtlsTransport> dtls_transport =
- rtc::make_ref_counted<DtlsTransport>(std::move(cricket_transport));
+ scoped_refptr<DtlsTransport> dtls_transport =
+ make_ref_counted<DtlsTransport>(std::move(cricket_transport));
std::unique_ptr<SctpTransportInternal> fake_cricket_sctp_transport =
absl::WrapUnique(new FakeCricketSctpTransport());
- rtc::scoped_refptr<SctpTransport> sctp_transport =
- rtc::make_ref_counted<SctpTransport>(
- std::move(fake_cricket_sctp_transport), dtls_transport);
+ scoped_refptr<SctpTransport> sctp_transport = make_ref_counted<SctpTransport>(
+ std::move(fake_cricket_sctp_transport), dtls_transport);
ASSERT_TRUE(sctp_transport->internal());
ASSERT_EQ(SctpTransportState::kConnecting,
sctp_transport->Information().state());
diff --git a/pc/sctp_utils.cc b/pc/sctp_utils.cc
index b683e28..bc248cd 100644
--- a/pc/sctp_utils.cc
+++ b/pc/sctp_utils.cc
@@ -47,7 +47,7 @@
DCO_PRIORITY_HIGH = 1024,
};
-bool IsOpenMessage(const rtc::CopyOnWriteBuffer& payload) {
+bool IsOpenMessage(const CopyOnWriteBuffer& payload) {
// Format defined at
// https://www.rfc-editor.org/rfc/rfc8832#section-5.1
if (payload.size() < 1) {
@@ -59,7 +59,7 @@
return message_type == DATA_CHANNEL_OPEN_MESSAGE_TYPE;
}
-bool ParseDataChannelOpenMessage(const rtc::CopyOnWriteBuffer& payload,
+bool ParseDataChannelOpenMessage(const CopyOnWriteBuffer& payload,
std::string* label,
DataChannelInit* config) {
// Format defined at
@@ -138,7 +138,7 @@
return true;
}
-bool ParseDataChannelOpenAckMessage(const rtc::CopyOnWriteBuffer& payload) {
+bool ParseDataChannelOpenAckMessage(const CopyOnWriteBuffer& payload) {
if (payload.size() < 1) {
RTC_LOG(LS_WARNING) << "Could not read OPEN_ACK message type.";
return false;
@@ -155,7 +155,7 @@
bool WriteDataChannelOpenMessage(const std::string& label,
const DataChannelInit& config,
- rtc::CopyOnWriteBuffer* payload) {
+ CopyOnWriteBuffer* payload) {
return WriteDataChannelOpenMessage(label, config.protocol, config.priority,
config.ordered, config.maxRetransmits,
config.maxRetransmitTime, payload);
@@ -167,7 +167,7 @@
bool ordered,
std::optional<int> max_retransmits,
std::optional<int> max_retransmit_time,
- rtc::CopyOnWriteBuffer* payload) {
+ CopyOnWriteBuffer* payload) {
// Format defined at
// http://tools.ietf.org/html/draft-ietf-rtcweb-data-protocol-09#section-5.1
uint8_t channel_type = 0;
@@ -211,7 +211,7 @@
return true;
}
-void WriteDataChannelOpenAckMessage(rtc::CopyOnWriteBuffer* payload) {
+void WriteDataChannelOpenAckMessage(CopyOnWriteBuffer* payload) {
uint8_t data = DATA_CHANNEL_OPEN_ACK_MESSAGE_TYPE;
payload->SetData(&data, sizeof(data));
}
diff --git a/pc/sctp_utils.h b/pc/sctp_utils.h
index e2ded86..098f6e9 100644
--- a/pc/sctp_utils.h
+++ b/pc/sctp_utils.h
@@ -51,13 +51,13 @@
};
// Read the message type and return true if it's an OPEN message.
-bool IsOpenMessage(const rtc::CopyOnWriteBuffer& payload);
+bool IsOpenMessage(const CopyOnWriteBuffer& payload);
-bool ParseDataChannelOpenMessage(const rtc::CopyOnWriteBuffer& payload,
+bool ParseDataChannelOpenMessage(const CopyOnWriteBuffer& payload,
std::string* label,
DataChannelInit* config);
-bool ParseDataChannelOpenAckMessage(const rtc::CopyOnWriteBuffer& payload);
+bool ParseDataChannelOpenAckMessage(const CopyOnWriteBuffer& payload);
bool WriteDataChannelOpenMessage(const std::string& label,
const std::string& protocol,
@@ -65,11 +65,11 @@
bool ordered,
std::optional<int> max_retransmits,
std::optional<int> max_retransmit_time,
- rtc::CopyOnWriteBuffer* payload);
+ CopyOnWriteBuffer* payload);
bool WriteDataChannelOpenMessage(const std::string& label,
const DataChannelInit& config,
- rtc::CopyOnWriteBuffer* payload);
-void WriteDataChannelOpenAckMessage(rtc::CopyOnWriteBuffer* payload);
+ CopyOnWriteBuffer* payload);
+void WriteDataChannelOpenAckMessage(CopyOnWriteBuffer* payload);
} // namespace webrtc
diff --git a/pc/sctp_utils_unittest.cc b/pc/sctp_utils_unittest.cc
index 930a636..5e7d099 100644
--- a/pc/sctp_utils_unittest.cc
+++ b/pc/sctp_utils_unittest.cc
@@ -27,7 +27,7 @@
class SctpUtilsTest : public ::testing::Test {
public:
- void VerifyOpenMessageFormat(const rtc::CopyOnWriteBuffer& packet,
+ void VerifyOpenMessageFormat(const webrtc::CopyOnWriteBuffer& packet,
const std::string& label,
const webrtc::DataChannelInit& config) {
uint8_t message_type;
@@ -89,7 +89,7 @@
std::string label = "abc";
config.protocol = "y";
- rtc::CopyOnWriteBuffer packet;
+ webrtc::CopyOnWriteBuffer packet;
ASSERT_TRUE(webrtc::WriteDataChannelOpenMessage(label, config, &packet));
VerifyOpenMessageFormat(packet, label, config);
@@ -113,7 +113,7 @@
config.maxRetransmitTime = 10;
config.protocol = "y";
- rtc::CopyOnWriteBuffer packet;
+ webrtc::CopyOnWriteBuffer packet;
ASSERT_TRUE(webrtc::WriteDataChannelOpenMessage(label, config, &packet));
VerifyOpenMessageFormat(packet, label, config);
@@ -136,7 +136,7 @@
config.maxRetransmits = 10;
config.protocol = "y";
- rtc::CopyOnWriteBuffer packet;
+ webrtc::CopyOnWriteBuffer packet;
ASSERT_TRUE(webrtc::WriteDataChannelOpenMessage(label, config, &packet));
VerifyOpenMessageFormat(packet, label, config);
@@ -159,7 +159,7 @@
config.protocol = "y";
config.priority = webrtc::PriorityValue(webrtc::Priority::kVeryLow);
- rtc::CopyOnWriteBuffer packet;
+ webrtc::CopyOnWriteBuffer packet;
ASSERT_TRUE(webrtc::WriteDataChannelOpenMessage(label, config, &packet));
VerifyOpenMessageFormat(packet, label, config);
@@ -175,7 +175,7 @@
}
TEST_F(SctpUtilsTest, WriteParseAckMessage) {
- rtc::CopyOnWriteBuffer packet;
+ webrtc::CopyOnWriteBuffer packet;
webrtc::WriteDataChannelOpenAckMessage(&packet);
uint8_t message_type;
@@ -187,19 +187,19 @@
}
TEST_F(SctpUtilsTest, TestIsOpenMessage) {
- rtc::CopyOnWriteBuffer open(1);
+ webrtc::CopyOnWriteBuffer open(1);
open.MutableData()[0] = 0x03;
EXPECT_TRUE(webrtc::IsOpenMessage(open));
- rtc::CopyOnWriteBuffer openAck(1);
+ webrtc::CopyOnWriteBuffer openAck(1);
openAck.MutableData()[0] = 0x02;
EXPECT_FALSE(webrtc::IsOpenMessage(openAck));
- rtc::CopyOnWriteBuffer invalid(1);
+ webrtc::CopyOnWriteBuffer invalid(1);
invalid.MutableData()[0] = 0x01;
EXPECT_FALSE(webrtc::IsOpenMessage(invalid));
- rtc::CopyOnWriteBuffer empty;
+ webrtc::CopyOnWriteBuffer empty;
EXPECT_FALSE(webrtc::IsOpenMessage(empty));
}
diff --git a/pc/sdp_munging_detector.cc b/pc/sdp_munging_detector.cc
index a489579..baef265 100644
--- a/pc/sdp_munging_detector.cc
+++ b/pc/sdp_munging_detector.cc
@@ -31,8 +31,8 @@
namespace {
SdpMungingType DetermineTransportModification(
- const cricket::TransportInfos& last_created_transport_infos,
- const cricket::TransportInfos& transport_infos_to_set) {
+ const TransportInfos& last_created_transport_infos,
+ const TransportInfos& transport_infos_to_set) {
if (last_created_transport_infos.size() != transport_infos_to_set.size()) {
RTC_LOG(LS_WARNING) << "SDP munging: Number of transport-infos does not "
"match last created description.";
@@ -288,13 +288,13 @@
bool created_sim =
absl::c_find_if(
last_created_media_description->streams()[0].ssrc_groups,
- [](const cricket::SsrcGroup group) {
+ [](const SsrcGroup group) {
return group.semantics == kSimSsrcGroupSemantics;
}) !=
last_created_media_description->streams()[0].ssrc_groups.end();
bool set_sim =
absl::c_find_if(media_description_to_set->streams()[0].ssrc_groups,
- [](const cricket::SsrcGroup group) {
+ [](const SsrcGroup group) {
return group.semantics == kSimSsrcGroupSemantics;
}) !=
media_description_to_set->streams()[0].ssrc_groups.end();
diff --git a/pc/sdp_offer_answer.cc b/pc/sdp_offer_answer.cc
index 59604bc..d0289e3 100644
--- a/pc/sdp_offer_answer.cc
+++ b/pc/sdp_offer_answer.cc
@@ -103,9 +103,9 @@
#include "rtc_base/weak_ptr.h"
#include "system_wrappers/include/metrics.h"
-using cricket::MediaContentDescription;
using ::webrtc::ContentInfo;
using ::webrtc::ContentInfos;
+using webrtc::MediaContentDescription;
using ::webrtc::MediaProtocolType;
using ::webrtc::RidDescription;
using ::webrtc::RidDirection;
@@ -164,7 +164,7 @@
std::vector<const ContentGroup*> bundle_groups =
desc->GetGroupsByName(GROUP_TYPE_BUNDLE);
std::map<std::string, const ContentGroup*> bundle_groups_by_mid;
- for (const cricket::ContentGroup* bundle_group : bundle_groups) {
+ for (const ContentGroup* bundle_group : bundle_groups) {
for (const std::string& content_name : bundle_group->content_names()) {
bundle_groups_by_mid[content_name] = bundle_group;
}
@@ -217,7 +217,7 @@
return oss.Release();
}
-std::string GetStreamIdsString(rtc::ArrayView<const std::string> stream_ids) {
+std::string GetStreamIdsString(ArrayView<const std::string> stream_ids) {
std::string output = "streams=[";
const char* separator = "";
for (const auto& stream_id : stream_ids) {
@@ -320,7 +320,7 @@
const SessionDescription* desc,
bool dtls_enabled,
const std::map<std::string, const ContentGroup*>& bundle_groups_by_mid) {
- for (const cricket::ContentInfo& content_info : desc->contents()) {
+ for (const ContentInfo& content_info : desc->contents()) {
if (content_info.rejected) {
continue;
}
@@ -361,7 +361,7 @@
bool VerifyIceUfragPwdPresent(
const SessionDescription* desc,
const std::map<std::string, const ContentGroup*>& bundle_groups_by_mid) {
- for (const cricket::ContentInfo& content_info : desc->contents()) {
+ for (const ContentInfo& content_info : desc->contents()) {
if (content_info.rejected) {
continue;
}
@@ -395,7 +395,7 @@
RTCError ValidateMids(const SessionDescription& description) {
std::set<std::string> mids;
- for (const cricket::ContentInfo& content : description.contents()) {
+ for (const ContentInfo& content : description.contents()) {
if (content.mid().empty()) {
LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER,
"A media section is missing a MID attribute.");
@@ -440,7 +440,7 @@
// that can affect the codec configuration and packetization.
std::vector<const ContentGroup*> bundle_groups =
description.GetGroupsByName(GROUP_TYPE_BUNDLE);
- for (const cricket::ContentGroup* bundle_group : bundle_groups) {
+ for (const ContentGroup* bundle_group : bundle_groups) {
std::map<int, RtpCodecParameters> payload_to_codec_parameters;
for (const std::string& content_name : bundle_group->content_names()) {
const ContentInfo* content_description =
@@ -498,7 +498,7 @@
// extension across all the bundled media descriptions.
std::vector<const ContentGroup*> bundle_groups =
description.GetGroupsByName(GROUP_TYPE_BUNDLE);
- for (const cricket::ContentGroup* bundle_group : bundle_groups) {
+ for (const ContentGroup* bundle_group : bundle_groups) {
std::map<int, RtpExtension> id_to_extension;
for (const std::string& content_name : bundle_group->content_names()) {
const ContentInfo* content_description =
@@ -558,7 +558,7 @@
continue;
}
for (const StreamParams& stream : content.media_description()->streams()) {
- for (const cricket::SsrcGroup& group : stream.ssrc_groups) {
+ for (const SsrcGroup& group : stream.ssrc_groups) {
// Validate the number of SSRCs for standard SSRC group semantics such
// as FID and FEC-FR and the non-standard SIM group.
if ((group.semantics == kFidSsrcGroupSemantics &&
@@ -656,7 +656,7 @@
RTCError UpdateSimulcastLayerStatusInSender(
const std::vector<SimulcastLayer>& layers,
- rtc::scoped_refptr<RtpSenderInternal> sender) {
+ scoped_refptr<RtpSenderInternal> sender) {
RTC_DCHECK(sender);
RtpParameters parameters = sender->GetParametersInternalWithAllLayers();
std::vector<std::string> disabled_layers;
@@ -700,8 +700,7 @@
return simulcast_offered && (!simulcast_answered || !rids_supported);
}
-RTCError DisableSimulcastInSender(
- rtc::scoped_refptr<RtpSenderInternal> sender) {
+RTCError DisableSimulcastInSender(scoped_refptr<RtpSenderInternal> sender) {
RTC_DCHECK(sender);
RtpParameters parameters = sender->GetParametersInternalWithAllLayers();
if (parameters.encodings.size() <= 1) {
@@ -738,8 +737,8 @@
// Add options to |[audio/video]_media_description_options| from `senders`.
void AddPlanBRtpSenderOptions(
- const std::vector<rtc::scoped_refptr<
- RtpSenderProxyWithInternal<RtpSenderInternal>>>& senders,
+ const std::vector<
+ scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>>& senders,
MediaDescriptionOptions* audio_media_description_options,
MediaDescriptionOptions* video_media_description_options,
int num_sim_layers) {
@@ -878,7 +877,7 @@
return true;
}
-rtc::scoped_refptr<DtlsTransport> LookupDtlsTransportByMid(
+scoped_refptr<DtlsTransport> LookupDtlsTransportByMid(
Thread* network_thread,
JsepTransportController* controller,
const std::string& mid) {
@@ -942,7 +941,7 @@
RemoteDescriptionOperation(
SdpOfferAnswerHandler* handler,
std::unique_ptr<SessionDescriptionInterface> desc,
- rtc::scoped_refptr<SetRemoteDescriptionObserverInterface> observer,
+ scoped_refptr<SetRemoteDescriptionObserverInterface> observer,
std::function<void()> operations_chain_callback)
: handler_(handler),
desc_(std::move(desc)),
@@ -1168,7 +1167,7 @@
// is taking place since methods that depend on `old_remote_description()`
// for updating the state, need it.
std::unique_ptr<SessionDescriptionInterface> replaced_remote_description_;
- rtc::scoped_refptr<SetRemoteDescriptionObserverInterface> observer_;
+ scoped_refptr<SetRemoteDescriptionObserverInterface> observer_;
std::function<void()> operations_chain_callback_;
RTCError error_ = RTCError::OK();
std::map<std::string, const ContentGroup*> bundle_groups_by_mid_;
@@ -1183,7 +1182,7 @@
public:
ImplicitCreateSessionDescriptionObserver(
WeakPtr<SdpOfferAnswerHandler> sdp_handler,
- rtc::scoped_refptr<SetLocalDescriptionObserverInterface>
+ scoped_refptr<SetLocalDescriptionObserverInterface>
set_local_description_observer)
: sdp_handler_(std::move(sdp_handler)),
set_local_description_observer_(
@@ -1229,7 +1228,7 @@
private:
bool was_called_ = false;
WeakPtr<SdpOfferAnswerHandler> sdp_handler_;
- rtc::scoped_refptr<SetLocalDescriptionObserverInterface>
+ scoped_refptr<SetLocalDescriptionObserverInterface>
set_local_description_observer_;
std::function<void()> operation_complete_callback_;
};
@@ -1241,7 +1240,7 @@
: public CreateSessionDescriptionObserver {
public:
CreateSessionDescriptionObserverOperationWrapper(
- rtc::scoped_refptr<CreateSessionDescriptionObserver> observer,
+ scoped_refptr<CreateSessionDescriptionObserver> observer,
std::function<void()> operation_complete_callback)
: observer_(std::move(observer)),
operation_complete_callback_(std::move(operation_complete_callback)) {
@@ -1277,7 +1276,7 @@
#if RTC_DCHECK_IS_ON
bool was_called_ = false;
#endif // RTC_DCHECK_IS_ON
- rtc::scoped_refptr<CreateSessionDescriptionObserver> observer_;
+ scoped_refptr<CreateSessionDescriptionObserver> observer_;
std::function<void()> operation_complete_callback_;
};
@@ -1288,7 +1287,7 @@
public:
CreateDescriptionObserverWrapperWithCreationCallback(
std::function<void(const SessionDescriptionInterface* desc)> callback,
- rtc::scoped_refptr<CreateSessionDescriptionObserver> observer)
+ scoped_refptr<CreateSessionDescriptionObserver> observer)
: callback_(callback), observer_(observer) {
RTC_DCHECK(observer_);
}
@@ -1303,7 +1302,7 @@
private:
std::function<void(const SessionDescriptionInterface* desc)> callback_;
- rtc::scoped_refptr<CreateSessionDescriptionObserver> observer_;
+ scoped_refptr<CreateSessionDescriptionObserver> observer_;
};
// Wrapper for SetSessionDescriptionObserver that invokes the success or failure
@@ -1320,7 +1319,7 @@
public:
SetSessionDescriptionObserverAdapter(
WeakPtr<SdpOfferAnswerHandler> handler,
- rtc::scoped_refptr<SetSessionDescriptionObserver> inner_observer)
+ scoped_refptr<SetSessionDescriptionObserver> inner_observer)
: handler_(std::move(handler)),
inner_observer_(std::move(inner_observer)) {}
@@ -1347,7 +1346,7 @@
}
WeakPtr<SdpOfferAnswerHandler> handler_;
- rtc::scoped_refptr<SetSessionDescriptionObserver> inner_observer_;
+ scoped_refptr<SetSessionDescriptionObserver> inner_observer_;
};
class SdpOfferAnswerHandler::LocalIceCredentialsToReplace {
@@ -1458,7 +1457,7 @@
configuration.audio_jitter_buffer_min_delay_ms;
// Obtain a certificate from RTCConfiguration if any were provided (optional).
- rtc::scoped_refptr<RTCCertificate> certificate;
+ scoped_refptr<RTCCertificate> certificate;
if (!configuration.certificates.empty()) {
// TODO(hbos,torbjorng): Decide on certificate-selection strategy instead of
// just picking the first one. The decision should be made based on the DTLS
@@ -1470,7 +1469,7 @@
std::make_unique<WebRtcSessionDescriptionFactory>(
context, this, pc_->session_id(), pc_->dtls_enabled(),
std::move(cert_generator), std::move(certificate),
- [this](const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) {
+ [this](const scoped_refptr<RTCCertificate>& certificate) {
RTC_DCHECK_RUN_ON(signaling_thread());
transport_controller_s()->SetLocalCertificate(certificate);
},
@@ -1583,7 +1582,7 @@
operations_chain_->ChainOperation(
[this_weak_ptr = weak_ptr_factory_.GetWeakPtr(),
observer_refptr =
- rtc::scoped_refptr<CreateSessionDescriptionObserver>(observer),
+ scoped_refptr<CreateSessionDescriptionObserver>(observer),
options](std::function<void()> operations_chain_callback) {
// Abort early if `this_weak_ptr` is no longer valid.
if (!this_weak_ptr) {
@@ -1594,9 +1593,10 @@
return;
}
// The operation completes asynchronously when the wrapper is invoked.
- auto observer_wrapper = rtc::make_ref_counted<
- CreateSessionDescriptionObserverOperationWrapper>(
- std::move(observer_refptr), std::move(operations_chain_callback));
+ auto observer_wrapper =
+ make_ref_counted<CreateSessionDescriptionObserverOperationWrapper>(
+ std::move(observer_refptr),
+ std::move(operations_chain_callback));
this_weak_ptr->DoCreateOffer(options, observer_wrapper);
});
}
@@ -1610,8 +1610,7 @@
// lambda will execute immediately.
operations_chain_->ChainOperation(
[this_weak_ptr = weak_ptr_factory_.GetWeakPtr(),
- observer_refptr =
- rtc::scoped_refptr<SetSessionDescriptionObserver>(observer),
+ observer_refptr = scoped_refptr<SetSessionDescriptionObserver>(observer),
desc = std::unique_ptr<SessionDescriptionInterface>(desc_ptr)](
std::function<void()> operations_chain_callback) mutable {
// Abort early if `this_weak_ptr` is no longer valid.
@@ -1626,7 +1625,7 @@
// `observer_refptr` is invoked in a posted message.
this_weak_ptr->DoSetLocalDescription(
std::move(desc),
- rtc::make_ref_counted<SetSessionDescriptionObserverAdapter>(
+ make_ref_counted<SetSessionDescriptionObserverAdapter>(
this_weak_ptr, observer_refptr));
// For backwards-compatability reasons, we declare the operation as
// completed here (rather than in a post), so that the operation chain
@@ -1639,7 +1638,7 @@
void SdpOfferAnswerHandler::SetLocalDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
- rtc::scoped_refptr<SetLocalDescriptionObserverInterface> observer) {
+ scoped_refptr<SetLocalDescriptionObserverInterface> observer) {
RTC_DCHECK_RUN_ON(signaling_thread());
// Chain this operation. If asynchronous operations are pending on the chain,
// this operation will be queued to be invoked, otherwise the contents of the
@@ -1667,19 +1666,18 @@
void SdpOfferAnswerHandler::SetLocalDescription(
SetSessionDescriptionObserver* observer) {
RTC_DCHECK_RUN_ON(signaling_thread());
- SetLocalDescription(
- rtc::make_ref_counted<SetSessionDescriptionObserverAdapter>(
- weak_ptr_factory_.GetWeakPtr(),
- rtc::scoped_refptr<SetSessionDescriptionObserver>(observer)));
+ SetLocalDescription(make_ref_counted<SetSessionDescriptionObserverAdapter>(
+ weak_ptr_factory_.GetWeakPtr(),
+ scoped_refptr<SetSessionDescriptionObserver>(observer)));
}
void SdpOfferAnswerHandler::SetLocalDescription(
- rtc::scoped_refptr<SetLocalDescriptionObserverInterface> observer) {
+ scoped_refptr<SetLocalDescriptionObserverInterface> observer) {
RTC_DCHECK_RUN_ON(signaling_thread());
// The `create_sdp_observer` handles performing DoSetLocalDescription() with
// the resulting description as well as completing the operation.
auto create_sdp_observer =
- rtc::make_ref_counted<ImplicitCreateSessionDescriptionObserver>(
+ make_ref_counted<ImplicitCreateSessionDescriptionObserver>(
weak_ptr_factory_.GetWeakPtr(), observer);
// Chain this operation. If asynchronous operations are pending on the chain,
// this operation will be queued to be invoked, otherwise the contents of the
@@ -1792,8 +1790,8 @@
return error;
}
if (ConfiguredForMedia()) {
- std::vector<rtc::scoped_refptr<RtpTransceiverInterface>> remove_list;
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> removed_streams;
+ std::vector<scoped_refptr<RtpTransceiverInterface>> remove_list;
+ std::vector<scoped_refptr<MediaStreamInterface>> removed_streams;
for (const auto& transceiver_ext : transceivers()->List()) {
auto transceiver = transceiver_ext->internal();
if (transceiver->stopped()) {
@@ -1992,8 +1990,7 @@
// lambda will execute immediately.
operations_chain_->ChainOperation(
[this_weak_ptr = weak_ptr_factory_.GetWeakPtr(),
- observer_refptr =
- rtc::scoped_refptr<SetSessionDescriptionObserver>(observer),
+ observer_refptr = scoped_refptr<SetSessionDescriptionObserver>(observer),
desc = std::unique_ptr<SessionDescriptionInterface>(desc_ptr)](
std::function<void()> operations_chain_callback) mutable {
// Abort early if `this_weak_ptr` is no longer valid.
@@ -2009,7 +2006,7 @@
this_weak_ptr->DoSetRemoteDescription(
std::make_unique<RemoteDescriptionOperation>(
this_weak_ptr.get(), std::move(desc),
- rtc::make_ref_counted<SetSessionDescriptionObserverAdapter>(
+ make_ref_counted<SetSessionDescriptionObserverAdapter>(
this_weak_ptr, observer_refptr),
std::move(operations_chain_callback)));
});
@@ -2017,7 +2014,7 @@
void SdpOfferAnswerHandler::SetRemoteDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
- rtc::scoped_refptr<SetRemoteDescriptionObserverInterface> observer) {
+ scoped_refptr<SetRemoteDescriptionObserverInterface> observer) {
RTC_DCHECK_RUN_ON(signaling_thread());
// Chain this operation. If asynchronous operations are pending on the chain,
// this operation will be queued to be invoked, otherwise the contents of the
@@ -2102,7 +2099,7 @@
return;
if (operation->old_remote_description()) {
- for (const cricket::ContentInfo& content :
+ for (const ContentInfo& content :
operation->old_remote_description()->description()->contents()) {
// Check if this new SessionDescription contains new ICE ufrag and
// password that indicates the remote peer requests an ICE restart.
@@ -2188,11 +2185,11 @@
if (!ConfiguredForMedia()) {
return;
}
- std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>
+ std::vector<scoped_refptr<RtpTransceiverInterface>>
now_receiving_transceivers;
- std::vector<rtc::scoped_refptr<RtpTransceiverInterface>> remove_list;
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> added_streams;
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> removed_streams;
+ std::vector<scoped_refptr<RtpTransceiverInterface>> remove_list;
+ std::vector<scoped_refptr<MediaStreamInterface>> added_streams;
+ std::vector<scoped_refptr<MediaStreamInterface>> removed_streams;
for (const auto& transceiver_ext : transceivers()->List()) {
const auto transceiver = transceiver_ext->internal();
const ContentInfo* content =
@@ -2319,7 +2316,7 @@
// We wait to signal new streams until we finish processing the description,
// since only at that point will new streams have all their tracks.
- rtc::scoped_refptr<StreamCollection> new_streams(StreamCollection::Create());
+ scoped_refptr<StreamCollection> new_streams(StreamCollection::Create());
// TODO(steveanton): When removing RTP senders/receivers in response to a
// rejected media section, there is some cleanup logic that expects the
@@ -2364,7 +2361,7 @@
for (size_t i = 0; i < new_streams->count(); ++i) {
MediaStreamInterface* new_stream = new_streams->at(i);
pc_->legacy_stats()->AddStream(new_stream);
- observer->OnAddStream(rtc::scoped_refptr<MediaStreamInterface>(new_stream));
+ observer->OnAddStream(scoped_refptr<MediaStreamInterface>(new_stream));
}
UpdateEndedRemoteMediaStreams();
@@ -2399,7 +2396,7 @@
void SdpOfferAnswerHandler::DoSetLocalDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
- rtc::scoped_refptr<SetLocalDescriptionObserverInterface> observer) {
+ scoped_refptr<SetLocalDescriptionObserverInterface> observer) {
RTC_DCHECK_RUN_ON(signaling_thread());
TRACE_EVENT0("webrtc", "SdpOfferAnswerHandler::DoSetLocalDescription");
@@ -2534,7 +2531,7 @@
void SdpOfferAnswerHandler::DoCreateOffer(
const PeerConnectionInterface::RTCOfferAnswerOptions& options,
- rtc::scoped_refptr<CreateSessionDescriptionObserver> observer) {
+ scoped_refptr<CreateSessionDescriptionObserver> observer) {
RTC_DCHECK_RUN_ON(signaling_thread());
TRACE_EVENT0("webrtc", "SdpOfferAnswerHandler::DoCreateOffer");
@@ -2585,17 +2582,17 @@
MediaSessionOptions session_options;
GetOptionsForOffer(options, &session_options);
- auto observer_wrapper = rtc::make_ref_counted<
- CreateDescriptionObserverWrapperWithCreationCallback>(
- [this](const SessionDescriptionInterface* desc) {
- RTC_DCHECK_RUN_ON(signaling_thread());
- if (desc) {
- last_created_offer_ = desc->Clone();
- } else {
- last_created_offer_.reset(nullptr);
- }
- },
- std::move(observer));
+ auto observer_wrapper =
+ make_ref_counted<CreateDescriptionObserverWrapperWithCreationCallback>(
+ [this](const SessionDescriptionInterface* desc) {
+ RTC_DCHECK_RUN_ON(signaling_thread());
+ if (desc) {
+ last_created_offer_ = desc->Clone();
+ } else {
+ last_created_offer_.reset(nullptr);
+ }
+ },
+ std::move(observer));
webrtc_session_desc_factory_->CreateOffer(observer_wrapper.get(), options,
session_options);
}
@@ -2611,7 +2608,7 @@
operations_chain_->ChainOperation(
[this_weak_ptr = weak_ptr_factory_.GetWeakPtr(),
observer_refptr =
- rtc::scoped_refptr<CreateSessionDescriptionObserver>(observer),
+ scoped_refptr<CreateSessionDescriptionObserver>(observer),
options](std::function<void()> operations_chain_callback) {
// Abort early if `this_weak_ptr` is no longer valid.
if (!this_weak_ptr) {
@@ -2622,16 +2619,17 @@
return;
}
// The operation completes asynchronously when the wrapper is invoked.
- auto observer_wrapper = rtc::make_ref_counted<
- CreateSessionDescriptionObserverOperationWrapper>(
- std::move(observer_refptr), std::move(operations_chain_callback));
+ auto observer_wrapper =
+ make_ref_counted<CreateSessionDescriptionObserverOperationWrapper>(
+ std::move(observer_refptr),
+ std::move(operations_chain_callback));
this_weak_ptr->DoCreateAnswer(options, observer_wrapper);
});
}
void SdpOfferAnswerHandler::DoCreateAnswer(
const PeerConnectionInterface::RTCOfferAnswerOptions& options,
- rtc::scoped_refptr<CreateSessionDescriptionObserver> observer) {
+ scoped_refptr<CreateSessionDescriptionObserver> observer) {
RTC_DCHECK_RUN_ON(signaling_thread());
TRACE_EVENT0("webrtc", "SdpOfferAnswerHandler::DoCreateAnswer");
if (!observer) {
@@ -2682,17 +2680,17 @@
MediaSessionOptions session_options;
GetOptionsForAnswer(options, &session_options);
- auto observer_wrapper = rtc::make_ref_counted<
- CreateDescriptionObserverWrapperWithCreationCallback>(
- [this](const SessionDescriptionInterface* desc) {
- RTC_DCHECK_RUN_ON(signaling_thread());
- if (desc) {
- last_created_answer_ = desc->Clone();
- } else {
- last_created_answer_.reset(nullptr);
- }
- },
- std::move(observer));
+ auto observer_wrapper =
+ make_ref_counted<CreateDescriptionObserverWrapperWithCreationCallback>(
+ [this](const SessionDescriptionInterface* desc) {
+ RTC_DCHECK_RUN_ON(signaling_thread());
+ if (desc) {
+ last_created_answer_ = desc->Clone();
+ } else {
+ last_created_answer_.reset(nullptr);
+ }
+ },
+ std::move(observer));
webrtc_session_desc_factory_->CreateAnswer(observer_wrapper.get(),
session_options);
}
@@ -2752,14 +2750,14 @@
}
void SdpOfferAnswerHandler::SetAssociatedRemoteStreams(
- rtc::scoped_refptr<RtpReceiverInternal> receiver,
+ scoped_refptr<RtpReceiverInternal> receiver,
const std::vector<std::string>& stream_ids,
- std::vector<rtc::scoped_refptr<MediaStreamInterface>>* added_streams,
- std::vector<rtc::scoped_refptr<MediaStreamInterface>>* removed_streams) {
+ std::vector<scoped_refptr<MediaStreamInterface>>* added_streams,
+ std::vector<scoped_refptr<MediaStreamInterface>>* removed_streams) {
RTC_DCHECK_RUN_ON(signaling_thread());
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> media_streams;
+ std::vector<scoped_refptr<MediaStreamInterface>> media_streams;
for (const std::string& stream_id : stream_ids) {
- rtc::scoped_refptr<MediaStreamInterface> stream(
+ scoped_refptr<MediaStreamInterface> stream(
remote_streams_->find(stream_id));
if (!stream) {
stream = MediaStreamProxy::Create(Thread::Current(),
@@ -2780,7 +2778,7 @@
}
media_streams.push_back(missing_msid_default_stream_);
}
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> previous_streams =
+ std::vector<scoped_refptr<MediaStreamInterface>> previous_streams =
receiver->streams();
// SetStreams() will add/remove the receiver's track to/from the streams.
// This differs from the spec - the spec uses an "addList" and "removeList"
@@ -3094,7 +3092,7 @@
return true;
}
-rtc::scoped_refptr<StreamCollectionInterface>
+scoped_refptr<StreamCollectionInterface>
SdpOfferAnswerHandler::local_streams() {
RTC_DCHECK_RUN_ON(signaling_thread());
RTC_CHECK(!IsUnifiedPlan()) << "local_streams is not available with Unified "
@@ -3103,7 +3101,7 @@
return local_streams_;
}
-rtc::scoped_refptr<StreamCollectionInterface>
+scoped_refptr<StreamCollectionInterface>
SdpOfferAnswerHandler::remote_streams() {
RTC_DCHECK_RUN_ON(signaling_thread());
RTC_CHECK(!IsUnifiedPlan()) << "remote_streams is not available with Unified "
@@ -3123,8 +3121,7 @@
return false;
}
- local_streams_->AddStream(
- rtc::scoped_refptr<MediaStreamInterface>(local_stream));
+ local_streams_->AddStream(scoped_refptr<MediaStreamInterface>(local_stream));
auto observer = std::make_unique<MediaStreamObserver>(
local_stream,
[this](AudioTrackInterface* audio_track,
@@ -3239,11 +3236,11 @@
}
RTC_DCHECK_RUN_ON(signaling_thread());
RTC_DCHECK(IsUnifiedPlan());
- std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>
+ std::vector<scoped_refptr<RtpTransceiverInterface>>
now_receiving_transceivers;
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> all_added_streams;
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> all_removed_streams;
- std::vector<rtc::scoped_refptr<RtpReceiverInterface>> removed_receivers;
+ std::vector<scoped_refptr<MediaStreamInterface>> all_added_streams;
+ std::vector<scoped_refptr<MediaStreamInterface>> all_removed_streams;
+ std::vector<scoped_refptr<RtpReceiverInterface>> removed_receivers;
for (auto&& transceivers_stable_state_pair : transceivers()->StableStates()) {
auto transceiver = transceivers_stable_state_pair.first;
@@ -3268,8 +3265,8 @@
}
if (stable_state.remote_stream_ids()) {
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> added_streams;
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> removed_streams;
+ std::vector<scoped_refptr<MediaStreamInterface>> added_streams;
+ std::vector<scoped_refptr<MediaStreamInterface>> removed_streams;
SetAssociatedRemoteStreams(transceiver->internal()->receiver_internal(),
stable_state.remote_stream_ids().value(),
&added_streams, &removed_streams);
@@ -3943,7 +3940,7 @@
return RTCError::OK();
}
-RTCErrorOr<rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
+RTCErrorOr<scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
SdpOfferAnswerHandler::AssociateTransceiver(
ContentSource source,
SdpType type,
@@ -4079,8 +4076,7 @@
}
RTCError SdpOfferAnswerHandler::UpdateTransceiverChannel(
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
- transceiver,
+ scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>> transceiver,
const ContentInfo& content,
const ContentGroup* bundle_group) {
TRACE_EVENT0("webrtc", "SdpOfferAnswerHandler::UpdateTransceiverChannel");
@@ -4157,11 +4153,11 @@
SessionDescription* new_remote_description) {
RTC_DCHECK_RUN_ON(signaling_thread());
RTC_DCHECK(new_remote_description);
- const cricket::ContentInfos no_infos;
- const cricket::ContentInfos& local_contents =
+ const ContentInfos no_infos;
+ const ContentInfos& local_contents =
(local_description() ? local_description()->description()->contents()
: no_infos);
- const cricket::ContentInfos& remote_contents =
+ const ContentInfos& remote_contents =
(remote_description() ? remote_description()->description()->contents()
: no_infos);
for (size_t i = 0; i < new_remote_description->contents().size(); ++i) {
@@ -4196,7 +4192,7 @@
}
}
-rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
SdpOfferAnswerHandler::FindAvailableTransceiverToReceive(
webrtc::MediaType media_type) const {
RTC_DCHECK_RUN_ON(signaling_thread());
@@ -4746,11 +4742,10 @@
}
}
-std::vector<rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
+std::vector<scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
SdpOfferAnswerHandler::GetReceivingTransceiversOfType(
webrtc::MediaType media_type) {
- std::vector<
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
+ std::vector<scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
receiving_transceivers;
for (const auto& transceiver : transceivers()->List()) {
if (!transceiver->stopped() && transceiver->media_type() == media_type &&
@@ -4762,14 +4757,13 @@
}
void SdpOfferAnswerHandler::ProcessRemovalOfRemoteTrack(
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
- transceiver,
- std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>* remove_list,
- std::vector<rtc::scoped_refptr<MediaStreamInterface>>* removed_streams) {
+ scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>> transceiver,
+ std::vector<scoped_refptr<RtpTransceiverInterface>>* remove_list,
+ std::vector<scoped_refptr<MediaStreamInterface>>* removed_streams) {
RTC_DCHECK(transceiver->mid());
RTC_LOG(LS_INFO) << "Processing the removal of a track for MID="
<< *transceiver->mid();
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> previous_streams =
+ std::vector<scoped_refptr<MediaStreamInterface>> previous_streams =
transceiver->internal()->receiver_internal()->streams();
// This will remove the remote track from the streams.
transceiver->internal()->receiver_internal()->set_stream_ids({});
@@ -4778,8 +4772,8 @@
}
void SdpOfferAnswerHandler::RemoveRemoteStreamsIfEmpty(
- const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& remote_streams,
- std::vector<rtc::scoped_refptr<MediaStreamInterface>>* removed_streams) {
+ const std::vector<scoped_refptr<MediaStreamInterface>>& remote_streams,
+ std::vector<scoped_refptr<MediaStreamInterface>>* removed_streams) {
RTC_DCHECK_RUN_ON(signaling_thread());
// TODO(https://crbug.com/webrtc/9480): When we use stream IDs instead of
// streams, see if the stream was removed by checking if this was the last
@@ -4825,7 +4819,7 @@
}
// Find new and active senders.
- for (const cricket::StreamParams& params : streams) {
+ for (const StreamParams& params : streams) {
// The sync_label is the MediaStream label and the `stream.id` is the
// sender id.
const std::string& stream_id = params.first_stream_id();
@@ -4841,7 +4835,7 @@
}
void SdpOfferAnswerHandler::UpdateRemoteSendersList(
- const cricket::StreamParamsVec& streams,
+ const StreamParamsVec& streams,
bool default_sender_needed,
webrtc::MediaType media_type,
StreamCollection* new_streams) {
@@ -4879,7 +4873,7 @@
}
// Find new and active senders.
- for (const cricket::StreamParams& params : streams) {
+ for (const StreamParams& params : streams) {
if (!params.has_ssrcs()) {
// The remote endpoint has streams, but didn't signal ssrcs. For an active
// sender, this means it is coming from a Unified Plan endpoint,so we just
@@ -4899,7 +4893,7 @@
const std::string& sender_id = params.id;
uint32_t ssrc = params.first_ssrc();
- rtc::scoped_refptr<MediaStreamInterface> stream(
+ scoped_refptr<MediaStreamInterface> stream(
remote_streams_->find(stream_id));
if (!stream) {
// This is a new MediaStream. Create a new remote MediaStream.
@@ -4920,7 +4914,7 @@
// Add default sender if necessary.
if (default_sender_needed) {
- rtc::scoped_refptr<MediaStreamInterface> default_stream(
+ scoped_refptr<MediaStreamInterface> default_stream(
remote_streams_->find(kDefaultStreamId));
if (!default_stream) {
// Create the new default MediaStream.
@@ -5168,12 +5162,11 @@
void SdpOfferAnswerHandler::UpdateEndedRemoteMediaStreams() {
RTC_DCHECK_RUN_ON(signaling_thread());
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams_to_remove;
+ std::vector<scoped_refptr<MediaStreamInterface>> streams_to_remove;
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(
- rtc::scoped_refptr<MediaStreamInterface>(stream));
+ streams_to_remove.push_back(scoped_refptr<MediaStreamInterface>(stream));
}
}
@@ -5273,8 +5266,8 @@
const IceCandidateInterface* candidate) {
if (!candidate->sdp_mid().empty()) {
auto& contents = description->description()->contents();
- auto it = absl::c_find_if(
- contents, [candidate](const cricket::ContentInfo& content_info) {
+ auto it =
+ absl::c_find_if(contents, [candidate](const ContentInfo& content_info) {
return content_info.mid() == candidate->sdp_mid();
});
if (it == contents.end()) {
@@ -5388,8 +5381,7 @@
std::optional<size_t>* data_index,
MediaSessionOptions* session_options) {
RTC_DCHECK_RUN_ON(signaling_thread());
- for (const cricket::ContentInfo& content :
- session_desc->description()->contents()) {
+ for (const ContentInfo& content : session_desc->description()->contents()) {
if (IsAudioContent(&content)) {
// If we already have an audio m= section, reject this extra one.
if (*audio_index) {
diff --git a/pc/sdp_offer_answer.h b/pc/sdp_offer_answer.h
index 453e4bc..c91b252 100644
--- a/pc/sdp_offer_answer.h
+++ b/pc/sdp_offer_answer.h
@@ -131,16 +131,16 @@
void SetLocalDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
- rtc::scoped_refptr<SetLocalDescriptionObserverInterface> observer);
+ scoped_refptr<SetLocalDescriptionObserverInterface> observer);
void SetLocalDescription(
- rtc::scoped_refptr<SetLocalDescriptionObserverInterface> observer);
+ scoped_refptr<SetLocalDescriptionObserverInterface> observer);
void SetLocalDescription(SetSessionDescriptionObserver* observer,
SessionDescriptionInterface* desc);
void SetLocalDescription(SetSessionDescriptionObserver* observer);
void SetRemoteDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
- rtc::scoped_refptr<SetRemoteDescriptionObserverInterface> observer);
+ scoped_refptr<SetRemoteDescriptionObserverInterface> observer);
void SetRemoteDescription(SetSessionDescriptionObserver* observer,
SessionDescriptionInterface* desc);
@@ -172,8 +172,8 @@
// Destroys all media BaseChannels.
void DestroyMediaChannels();
- rtc::scoped_refptr<StreamCollectionInterface> local_streams();
- rtc::scoped_refptr<StreamCollectionInterface> remote_streams();
+ scoped_refptr<StreamCollectionInterface> local_streams();
+ scoped_refptr<StreamCollectionInterface> remote_streams();
bool initial_offerer() {
RTC_DCHECK_RUN_ON(signaling_thread());
@@ -268,13 +268,13 @@
// SetLocalDescription() and SetRemoteDescription() methods are invoked.
void DoCreateOffer(
const PeerConnectionInterface::RTCOfferAnswerOptions& options,
- rtc::scoped_refptr<CreateSessionDescriptionObserver> observer);
+ scoped_refptr<CreateSessionDescriptionObserver> observer);
void DoCreateAnswer(
const PeerConnectionInterface::RTCOfferAnswerOptions& options,
- rtc::scoped_refptr<CreateSessionDescriptionObserver> observer);
+ scoped_refptr<CreateSessionDescriptionObserver> observer);
void DoSetLocalDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
- rtc::scoped_refptr<SetLocalDescriptionObserverInterface> observer);
+ scoped_refptr<SetLocalDescriptionObserverInterface> observer);
void DoSetRemoteDescription(
std::unique_ptr<RemoteDescriptionOperation> operation);
@@ -315,10 +315,10 @@
// Runs the algorithm **set the associated remote streams** specified in
// https://w3c.github.io/webrtc-pc/#set-associated-remote-streams.
void SetAssociatedRemoteStreams(
- rtc::scoped_refptr<RtpReceiverInternal> receiver,
+ scoped_refptr<RtpReceiverInternal> receiver,
const std::vector<std::string>& stream_ids,
- std::vector<rtc::scoped_refptr<MediaStreamInterface>>* added_streams,
- std::vector<rtc::scoped_refptr<MediaStreamInterface>>* removed_streams);
+ std::vector<scoped_refptr<MediaStreamInterface>>* added_streams,
+ std::vector<scoped_refptr<MediaStreamInterface>>* removed_streams);
bool CheckIfNegotiationIsNeeded();
void GenerateNegotiationNeededEvent();
@@ -339,8 +339,7 @@
const std::map<std::string, const ContentGroup*>& bundle_groups_by_mid);
// Associate the given transceiver according to the JSEP rules.
- RTCErrorOr<
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
+ RTCErrorOr<scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
AssociateTransceiver(ContentSource source,
SdpType type,
size_t mline_index,
@@ -360,7 +359,7 @@
// Either creates or destroys the transceiver's BaseChannel according to the
// given media section.
RTCError UpdateTransceiverChannel(
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+ scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
transceiver,
const ContentInfo& content,
const ContentGroup* bundle_group) RTC_RUN_ON(signaling_thread());
@@ -386,7 +385,7 @@
// Returns an RtpTransceiver, if available, that can be used to receive the
// given media type according to JSEP rules.
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+ scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
FindAvailableTransceiverToReceive(webrtc::MediaType media_type) const;
// Returns a MediaSessionOptions struct with options decided by `options`,
@@ -432,8 +431,7 @@
webrtc::MediaType media_type) RTC_RUN_ON(signaling_thread());
void AddUpToOneReceivingTransceiverOfType(webrtc::MediaType media_type);
- std::vector<
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
+ std::vector<scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
GetReceivingTransceiversOfType(webrtc::MediaType media_type)
RTC_RUN_ON(signaling_thread());
@@ -445,15 +443,14 @@
// `removed_streams` is the list of streams which no longer have a receiving
// track so should be removed.
void ProcessRemovalOfRemoteTrack(
- const rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+ const scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
transceiver,
- std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>* remove_list,
- std::vector<rtc::scoped_refptr<MediaStreamInterface>>* removed_streams);
+ std::vector<scoped_refptr<RtpTransceiverInterface>>* remove_list,
+ std::vector<scoped_refptr<MediaStreamInterface>>* removed_streams);
void RemoveRemoteStreamsIfEmpty(
- const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&
- remote_streams,
- std::vector<rtc::scoped_refptr<MediaStreamInterface>>* removed_streams);
+ const std::vector<scoped_refptr<MediaStreamInterface>>& remote_streams,
+ std::vector<scoped_refptr<MediaStreamInterface>>* removed_streams);
// Remove all local and remote senders of type `media_type`.
// Called when a media type is rejected (m-line set to port 0).
@@ -616,10 +613,10 @@
std::optional<bool> is_caller_ RTC_GUARDED_BY(signaling_thread());
// Streams added via AddStream.
- const rtc::scoped_refptr<StreamCollection> local_streams_
+ const scoped_refptr<StreamCollection> local_streams_
RTC_GUARDED_BY(signaling_thread());
// Streams created as a result of SetRemoteDescription.
- const rtc::scoped_refptr<StreamCollection> remote_streams_
+ const scoped_refptr<StreamCollection> remote_streams_
RTC_GUARDED_BY(signaling_thread());
std::vector<std::unique_ptr<MediaStreamObserver>> stream_observers_
@@ -630,7 +627,7 @@
// SetRemoteDescription() is invoked while CreateOffer() is still pending, the
// SRD operation will not start until CreateOffer() has completed. See
// https://w3c.github.io/webrtc-pc/#dfn-operations-chain.
- rtc::scoped_refptr<OperationsChain> operations_chain_
+ scoped_refptr<OperationsChain> operations_chain_
RTC_GUARDED_BY(signaling_thread());
// One PeerConnection has only one RTCP CNAME.
@@ -665,7 +662,7 @@
// line we create and use a stream with a random ID for our receivers. This is
// to support legacy endpoints that do not support the a=msid attribute (as
// opposed to streamless tracks with "a=msid:-").
- rtc::scoped_refptr<MediaStreamInterface> missing_msid_default_stream_
+ scoped_refptr<MediaStreamInterface> missing_msid_default_stream_
RTC_GUARDED_BY(signaling_thread());
SessionError session_error_ RTC_GUARDED_BY(signaling_thread()) =
diff --git a/pc/sdp_offer_answer_unittest.cc b/pc/sdp_offer_answer_unittest.cc
index 8315c9e..a48df74 100644
--- a/pc/sdp_offer_answer_unittest.cc
+++ b/pc/sdp_offer_answer_unittest.cc
@@ -153,7 +153,7 @@
protected:
std::unique_ptr<Thread> signaling_thread_;
- rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
+ scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
private:
AutoThread main_thread_;
@@ -2105,9 +2105,9 @@
ASSERT_TRUE(media_description);
std::vector<Codec> codecs = media_description->codecs();
for (auto& codec : codecs) {
- if (codec.name == cricket::kH264CodecName) {
- codec.SetParam(cricket::kH264FmtpSpsPpsIdrInKeyframe,
- cricket::kParamValueTrue);
+ if (codec.name == webrtc::kH264CodecName) {
+ codec.SetParam(webrtc::kH264FmtpSpsPpsIdrInKeyframe,
+ webrtc::kParamValueTrue);
}
}
media_description->set_codecs(codecs);
diff --git a/pc/sdp_utils.cc b/pc/sdp_utils.cc
index 010a3ae..33281e5 100644
--- a/pc/sdp_utils.cc
+++ b/pc/sdp_utils.cc
@@ -55,8 +55,8 @@
bool SdpContentsNone(SdpContentPredicate pred, const SessionDescription* desc) {
return SdpContentsAll(
- [pred](const cricket::ContentInfo* content_info,
- const cricket::TransportInfo* transport_info) {
+ [pred](const ContentInfo* content_info,
+ const TransportInfo* transport_info) {
return !pred(content_info, transport_info);
},
desc);
diff --git a/pc/session_description.cc b/pc/session_description.cc
index e436928..96ea3d9 100644
--- a/pc/session_description.cc
+++ b/pc/session_description.cc
@@ -204,8 +204,7 @@
}
bool SessionDescription::RemoveTransportInfoByName(const std::string& name) {
- for (cricket::TransportInfos::iterator transport_info =
- transport_infos_.begin();
+ for (TransportInfos::iterator transport_info = transport_infos_.begin();
transport_info != transport_infos_.end(); ++transport_info) {
if (transport_info->content_name == name) {
transport_infos_.erase(transport_info);
@@ -217,7 +216,7 @@
const TransportInfo* SessionDescription::GetTransportInfoByName(
const std::string& name) const {
- for (cricket::TransportInfos::const_iterator iter = transport_infos_.begin();
+ for (TransportInfos::const_iterator iter = transport_infos_.begin();
iter != transport_infos_.end(); ++iter) {
if (iter->content_name == name) {
return &(*iter);
@@ -228,7 +227,7 @@
TransportInfo* SessionDescription::GetTransportInfoByName(
const std::string& name) {
- for (cricket::TransportInfos::iterator iter = transport_infos_.begin();
+ for (TransportInfos::iterator iter = transport_infos_.begin();
iter != transport_infos_.end(); ++iter) {
if (iter->content_name == name) {
return &(*iter);
diff --git a/pc/session_description.h b/pc/session_description.h
index 4950e6e..bd08db4 100644
--- a/pc/session_description.h
+++ b/pc/session_description.h
@@ -154,10 +154,10 @@
// provide the ClearRtpHeaderExtensions method to allow "no support" to be
// clearly indicated (i.e. when derived from other information).
bool rtp_header_extensions_set() const { return rtp_header_extensions_set_; }
- const cricket::StreamParamsVec& streams() const { return send_streams_; }
+ const StreamParamsVec& streams() const { return send_streams_; }
// TODO(pthatcher): Remove this by giving mediamessage.cc access
// to MediaContentDescription
- cricket::StreamParamsVec& mutable_streams() { return send_streams_; }
+ StreamParamsVec& mutable_streams() { return send_streams_; }
void AddStream(const StreamParams& stream) {
send_streams_.push_back(stream);
}
@@ -270,7 +270,7 @@
std::vector<RtpExtension> rtp_header_extensions_;
bool rtp_header_extensions_set_ = false;
- cricket::StreamParamsVec send_streams_;
+ StreamParamsVec send_streams_;
bool conference_mode_ = false;
RtpTransceiverDirection direction_ = RtpTransceiverDirection::kSendRecv;
SocketAddress connection_address_;
@@ -530,10 +530,8 @@
bool RemoveContentByName(const std::string& name);
// Transport accessors.
- const cricket::TransportInfos& transport_infos() const {
- return transport_infos_;
- }
- cricket::TransportInfos& transport_infos() { return transport_infos_; }
+ const TransportInfos& transport_infos() const { return transport_infos_; }
+ TransportInfos& transport_infos() { return transport_infos_; }
const TransportInfo* GetTransportInfoByName(const std::string& name) const;
TransportInfo* GetTransportInfoByName(const std::string& name);
const TransportDescription* GetTransportDescriptionByName(
@@ -543,7 +541,7 @@
}
// Transport mutators.
- void set_transport_infos(const cricket::TransportInfos& transport_infos) {
+ void set_transport_infos(const TransportInfos& transport_infos) {
transport_infos_ = transport_infos;
}
// Adds a TransportInfo to this description.
@@ -592,7 +590,7 @@
SessionDescription(const SessionDescription&);
ContentInfos contents_;
- cricket::TransportInfos transport_infos_;
+ TransportInfos transport_infos_;
ContentGroups content_groups_;
int msid_signaling_ = kMsidSignalingMediaSection | kMsidSignalingSemantic;
bool extmap_allow_mixed_ = true;
diff --git a/pc/slow_peer_connection_integration_test.cc b/pc/slow_peer_connection_integration_test.cc
index 06716cb..d306989 100644
--- a/pc/slow_peer_connection_integration_test.cc
+++ b/pc/slow_peer_connection_integration_test.cc
@@ -178,7 +178,7 @@
// Enable TCP-TLS for the fake turn server. We need to pass in 88.88.88.0 so
// that host name verification passes on the fake certificate.
CreateTurnServer(turn_server_internal_address, turn_server_external_address,
- cricket::PROTO_TLS, "88.88.88.0");
+ PROTO_TLS, "88.88.88.0");
PeerConnectionInterface::IceServer ice_server;
ice_server.urls.push_back("turns:88.88.88.0:3478?transport=tcp");
@@ -285,7 +285,7 @@
}
bool TestIPv6() {
- return (port_allocator_flags_ & cricket::PORTALLOCATOR_ENABLE_IPV6);
+ return (port_allocator_flags_ & PORTALLOCATOR_ENABLE_IPV6);
}
std::vector<SocketAddress> CallerAddresses() {
@@ -403,7 +403,7 @@
// Block connections to/from the caller and wait for ICE to become
// disconnected.
for (const auto& caller_address : CallerAddresses()) {
- firewall()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, caller_address);
+ firewall()->AddRule(false, FP_ANY, FD_ANY, caller_address);
}
RTC_LOG(LS_INFO) << "Firewall rules applied";
ScopedFakeClock& fake_clock = FakeClock();
@@ -439,7 +439,7 @@
// is signaled by the state transitioning to "failed".
constexpr TimeDelta kConsentTimeout = TimeDelta::Millis(30000);
for (const auto& caller_address : CallerAddresses()) {
- firewall()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, caller_address);
+ firewall()->AddRule(false, FP_ANY, FD_ANY, caller_address);
}
RTC_LOG(LS_INFO) << "Firewall rules applied again";
ASSERT_THAT(
@@ -527,14 +527,14 @@
Values(SdpSemantics::kPlanB_DEPRECATED,
SdpSemantics::kUnifiedPlan));
-constexpr uint32_t kFlagsIPv4NoStun = cricket::PORTALLOCATOR_DISABLE_TCP |
- cricket::PORTALLOCATOR_DISABLE_STUN |
- cricket::PORTALLOCATOR_DISABLE_RELAY;
+constexpr uint32_t kFlagsIPv4NoStun = PORTALLOCATOR_DISABLE_TCP |
+ PORTALLOCATOR_DISABLE_STUN |
+ PORTALLOCATOR_DISABLE_RELAY;
constexpr uint32_t kFlagsIPv6NoStun =
- cricket::PORTALLOCATOR_DISABLE_TCP | cricket::PORTALLOCATOR_DISABLE_STUN |
- cricket::PORTALLOCATOR_ENABLE_IPV6 | cricket::PORTALLOCATOR_DISABLE_RELAY;
+ PORTALLOCATOR_DISABLE_TCP | PORTALLOCATOR_DISABLE_STUN |
+ PORTALLOCATOR_ENABLE_IPV6 | PORTALLOCATOR_DISABLE_RELAY;
constexpr uint32_t kFlagsIPv4Stun =
- cricket::PORTALLOCATOR_DISABLE_TCP | cricket::PORTALLOCATOR_DISABLE_RELAY;
+ PORTALLOCATOR_DISABLE_TCP | PORTALLOCATOR_DISABLE_RELAY;
INSTANTIATE_TEST_SUITE_P(
PeerConnectionIntegrationTest,
diff --git a/pc/srtp_session.cc b/pc/srtp_session.cc
index 047966c7..7fe7e04 100644
--- a/pc/srtp_session.cc
+++ b/pc/srtp_session.cc
@@ -174,25 +174,25 @@
}
bool SrtpSession::SetSend(int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key,
+ const ZeroOnFreeBuffer<uint8_t>& key,
const std::vector<int>& extension_ids) {
return SetKey(ssrc_any_outbound, crypto_suite, key, extension_ids);
}
bool SrtpSession::UpdateSend(int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key,
+ const ZeroOnFreeBuffer<uint8_t>& key,
const std::vector<int>& extension_ids) {
return UpdateKey(ssrc_any_outbound, crypto_suite, key, extension_ids);
}
bool SrtpSession::SetReceive(int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key,
+ const ZeroOnFreeBuffer<uint8_t>& key,
const std::vector<int>& extension_ids) {
return SetKey(ssrc_any_inbound, crypto_suite, key, extension_ids);
}
bool SrtpSession::UpdateReceive(int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key,
+ const ZeroOnFreeBuffer<uint8_t>& key,
const std::vector<int>& extension_ids) {
return UpdateKey(ssrc_any_inbound, crypto_suite, key, extension_ids);
}
@@ -257,7 +257,7 @@
*out_len = in_len;
int err = srtp_protect(session_, p, out_len);
int seq_num = webrtc::ParseRtpSequenceNumber(
- rtc::MakeArrayView(reinterpret_cast<const uint8_t*>(p), in_len));
+ MakeArrayView(reinterpret_cast<const uint8_t*>(p), in_len));
if (err != srtp_err_status_ok) {
RTC_LOG(LS_WARNING) << "Failed to protect SRTP packet, seqnum=" << seq_num
<< ", err=" << err
@@ -525,7 +525,7 @@
bool SrtpSession::DoSetKey(int type,
int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key,
+ const ZeroOnFreeBuffer<uint8_t>& key,
const std::vector<int>& extension_ids) {
RTC_DCHECK(thread_checker_.IsCurrent());
@@ -594,7 +594,7 @@
bool SrtpSession::SetKey(int type,
int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key,
+ const ZeroOnFreeBuffer<uint8_t>& key,
const std::vector<int>& extension_ids) {
RTC_DCHECK(thread_checker_.IsCurrent());
if (session_) {
@@ -617,7 +617,7 @@
bool SrtpSession::UpdateKey(int type,
int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key,
+ const ZeroOnFreeBuffer<uint8_t>& key,
const std::vector<int>& extension_ids) {
RTC_DCHECK(thread_checker_.IsCurrent());
if (!session_) {
diff --git a/pc/srtp_session.h b/pc/srtp_session.h
index 8006489..d2f4af3 100644
--- a/pc/srtp_session.h
+++ b/pc/srtp_session.h
@@ -45,19 +45,19 @@
// Configures the session for sending data using the specified
// crypto suite and key. Receiving must be done by a separate session.
bool SetSend(int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key,
+ const ZeroOnFreeBuffer<uint8_t>& key,
const std::vector<int>& extension_ids);
bool UpdateSend(int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key,
+ const ZeroOnFreeBuffer<uint8_t>& key,
const std::vector<int>& extension_ids);
// Configures the session for receiving data using the specified
// crypto suite and key. Sending must be done by a separate session.
bool SetReceive(int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key,
+ const ZeroOnFreeBuffer<uint8_t>& key,
const std::vector<int>& extension_ids);
bool UpdateReceive(int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key,
+ const ZeroOnFreeBuffer<uint8_t>& key,
const std::vector<int>& extension_ids);
// Encrypts/signs an individual RTP/RTCP packet, in-place.
@@ -120,15 +120,15 @@
private:
bool DoSetKey(int type,
int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key,
+ const ZeroOnFreeBuffer<uint8_t>& key,
const std::vector<int>& extension_ids);
bool SetKey(int type,
int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key,
+ const ZeroOnFreeBuffer<uint8_t>& key,
const std::vector<int>& extension_ids);
bool UpdateKey(int type,
int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key,
+ const ZeroOnFreeBuffer<uint8_t>& key,
const std::vector<int>& extension_ids);
// Returns send stream current packet index from srtp db.
bool GetSendStreamPacketIndex(CopyOnWriteBuffer& buffer, int64_t* index);
diff --git a/pc/srtp_session_unittest.cc b/pc/srtp_session_unittest.cc
index 300db77..fd58ce7 100644
--- a/pc/srtp_session_unittest.cc
+++ b/pc/srtp_session_unittest.cc
@@ -22,7 +22,7 @@
#include "rtc_base/buffer.h"
#include "rtc_base/byte_order.h"
#include "rtc_base/copy_on_write_buffer.h"
-#include "rtc_base/ssl_stream_adapter.h" // For rtc::SRTP_*
+#include "rtc_base/ssl_stream_adapter.h" // For webrtc::SRTP_*
#include "system_wrappers/include/metrics.h"
#include "test/gmock.h"
#include "test/gtest.h"
@@ -112,12 +112,12 @@
TEST_F(SrtpSessionTest, TestKeysTooShort) {
EXPECT_FALSE(
s1_.SetSend(webrtc::kSrtpAes128CmSha1_80,
- rtc::ZeroOnFreeBuffer<uint8_t>(webrtc::kTestKey1.data(), 1),
+ ZeroOnFreeBuffer<uint8_t>(webrtc::kTestKey1.data(), 1),
kEncryptedHeaderExtensionIds));
- EXPECT_FALSE(s2_.SetReceive(
- webrtc::kSrtpAes128CmSha1_80,
- rtc::ZeroOnFreeBuffer<uint8_t>(webrtc::kTestKey1.data(), 1),
- kEncryptedHeaderExtensionIds));
+ EXPECT_FALSE(
+ s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80,
+ ZeroOnFreeBuffer<uint8_t>(webrtc::kTestKey1.data(), 1),
+ kEncryptedHeaderExtensionIds));
}
// Test that we can encrypt and decrypt RTP/RTCP using AES_CM_128_HMAC_SHA1_80.
diff --git a/pc/srtp_transport.cc b/pc/srtp_transport.cc
index 8160cdd..62f4a14 100644
--- a/pc/srtp_transport.cc
+++ b/pc/srtp_transport.cc
@@ -39,8 +39,8 @@
: RtpTransport(rtcp_mux_enabled, field_trials),
field_trials_(field_trials) {}
-bool SrtpTransport::SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options,
+bool SrtpTransport::SendRtpPacket(CopyOnWriteBuffer* packet,
+ const AsyncSocketPacketOptions& options,
int flags) {
RTC_DCHECK(packet);
if (!IsSrtpActive()) {
@@ -48,7 +48,7 @@
<< "Failed to send the packet because SRTP transport is inactive.";
return false;
}
- rtc::PacketOptions updated_options = options;
+ AsyncSocketPacketOptions updated_options = options;
TRACE_EVENT0("webrtc", "SRTP Encode");
// If ENABLE_EXTERNAL_AUTH flag is on then packet authentication is not done
// inside libsrtp for a RTP packet. A external HMAC module will be writing
@@ -92,8 +92,8 @@
return SendPacket(/*rtcp=*/false, packet, updated_options, flags);
}
-bool SrtpTransport::SendRtcpPacket(rtc::CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options,
+bool SrtpTransport::SendRtcpPacket(CopyOnWriteBuffer* packet,
+ const AsyncSocketPacketOptions& options,
int flags) {
RTC_DCHECK(packet);
if (!IsSrtpActive()) {
@@ -114,7 +114,7 @@
return SendPacket(/*rtcp=*/true, packet, options, flags);
}
-void SrtpTransport::OnRtpPacketReceived(const rtc::ReceivedPacket& packet) {
+void SrtpTransport::OnRtpPacketReceived(const ReceivedIpPacket& packet) {
TRACE_EVENT0("webrtc", "SrtpTransport::OnRtpPacketReceived");
if (!IsSrtpActive()) {
RTC_LOG(LS_WARNING)
@@ -122,7 +122,7 @@
return;
}
- rtc::CopyOnWriteBuffer payload(packet.payload());
+ CopyOnWriteBuffer payload(packet.payload());
if (!UnprotectRtp(payload)) {
// Limit the error logging to avoid excessive logs when there are lots of
// bad packets.
@@ -143,14 +143,14 @@
packet.ecn());
}
-void SrtpTransport::OnRtcpPacketReceived(const rtc::ReceivedPacket& packet) {
+void SrtpTransport::OnRtcpPacketReceived(const ReceivedIpPacket& packet) {
TRACE_EVENT0("webrtc", "SrtpTransport::OnRtcpPacketReceived");
if (!IsSrtpActive()) {
RTC_LOG(LS_WARNING)
<< "Inactive SRTP transport received an RTCP packet. Drop it.";
return;
}
- rtc::CopyOnWriteBuffer payload(packet.payload());
+ CopyOnWriteBuffer payload(packet.payload());
if (!UnprotectRtcp(payload)) {
int type = -1;
GetRtcpType(payload.data(), payload.size(), &type);
@@ -180,10 +180,10 @@
}
bool SrtpTransport::SetRtpParams(int send_crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& send_key,
+ const ZeroOnFreeBuffer<uint8_t>& send_key,
const std::vector<int>& send_extension_ids,
int recv_crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& recv_key,
+ const ZeroOnFreeBuffer<uint8_t>& recv_key,
const std::vector<int>& recv_extension_ids) {
// If parameters are being set for the first time, we should create new SRTP
// sessions and call "SetSend/SetReceive". Otherwise we should call
@@ -222,13 +222,12 @@
return true;
}
-bool SrtpTransport::SetRtcpParams(
- int send_crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& send_key,
- const std::vector<int>& send_extension_ids,
- int recv_crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& recv_key,
- const std::vector<int>& recv_extension_ids) {
+bool SrtpTransport::SetRtcpParams(int send_crypto_suite,
+ const ZeroOnFreeBuffer<uint8_t>& send_key,
+ const std::vector<int>& send_extension_ids,
+ int recv_crypto_suite,
+ const ZeroOnFreeBuffer<uint8_t>& recv_key,
+ const std::vector<int>& recv_extension_ids) {
// This can only be called once, but can be safely called after
// SetRtpParams
if (send_rtcp_session_ || recv_rtcp_session_) {
@@ -281,7 +280,7 @@
}
}
-bool SrtpTransport::ProtectRtp(rtc::CopyOnWriteBuffer& buffer) {
+bool SrtpTransport::ProtectRtp(CopyOnWriteBuffer& buffer) {
if (!IsSrtpActive()) {
RTC_LOG(LS_WARNING) << "Failed to ProtectRtp: SRTP not active";
return false;
@@ -290,7 +289,7 @@
return send_session_->ProtectRtp(buffer);
}
-bool SrtpTransport::ProtectRtp(rtc::CopyOnWriteBuffer& buffer, int64_t* index) {
+bool SrtpTransport::ProtectRtp(CopyOnWriteBuffer& buffer, int64_t* index) {
if (!IsSrtpActive()) {
RTC_LOG(LS_WARNING) << "Failed to ProtectRtp: SRTP not active";
return false;
@@ -299,7 +298,7 @@
return send_session_->ProtectRtp(buffer, index);
}
-bool SrtpTransport::ProtectRtcp(rtc::CopyOnWriteBuffer& buffer) {
+bool SrtpTransport::ProtectRtcp(CopyOnWriteBuffer& buffer) {
if (!IsSrtpActive()) {
RTC_LOG(LS_WARNING) << "Failed to ProtectRtcp: SRTP not active";
return false;
@@ -312,7 +311,7 @@
}
}
-bool SrtpTransport::UnprotectRtp(rtc::CopyOnWriteBuffer& buffer) {
+bool SrtpTransport::UnprotectRtp(CopyOnWriteBuffer& buffer) {
if (!IsSrtpActive()) {
RTC_LOG(LS_WARNING) << "Failed to UnprotectRtp: SRTP not active";
return false;
@@ -321,7 +320,7 @@
return recv_session_->UnprotectRtp(buffer);
}
-bool SrtpTransport::UnprotectRtcp(rtc::CopyOnWriteBuffer& buffer) {
+bool SrtpTransport::UnprotectRtcp(CopyOnWriteBuffer& buffer) {
if (!IsSrtpActive()) {
RTC_LOG(LS_WARNING) << "Failed to UnprotectRtcp: SRTP not active";
return false;
diff --git a/pc/srtp_transport.h b/pc/srtp_transport.h
index 78f4090..1dddf3e 100644
--- a/pc/srtp_transport.h
+++ b/pc/srtp_transport.h
@@ -41,12 +41,12 @@
virtual ~SrtpTransport() = default;
- bool SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options,
+ bool SendRtpPacket(CopyOnWriteBuffer* packet,
+ const AsyncSocketPacketOptions& options,
int flags) override;
- bool SendRtcpPacket(rtc::CopyOnWriteBuffer* packet,
- const rtc::PacketOptions& options,
+ bool SendRtcpPacket(CopyOnWriteBuffer* packet,
+ const AsyncSocketPacketOptions& options,
int flags) override;
// The transport becomes active if the send_session_ and recv_session_ are
@@ -59,20 +59,20 @@
// packet encryption. The keys can either come from SDES negotiation or DTLS
// handshake.
bool SetRtpParams(int send_crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& send_key,
+ const ZeroOnFreeBuffer<uint8_t>& send_key,
const std::vector<int>& send_extension_ids,
int recv_crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& recv_key,
+ const ZeroOnFreeBuffer<uint8_t>& recv_key,
const std::vector<int>& recv_extension_ids);
// Create new send/recv sessions and set the negotiated crypto keys for RTCP
// packet encryption. The keys can either come from SDES negotiation or DTLS
// handshake.
bool SetRtcpParams(int send_crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& send_key,
+ const ZeroOnFreeBuffer<uint8_t>& send_key,
const std::vector<int>& send_extension_ids,
int recv_crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& recv_key,
+ const ZeroOnFreeBuffer<uint8_t>& recv_key,
const std::vector<int>& recv_extension_ids);
void ResetParams();
@@ -114,23 +114,23 @@
void ConnectToRtpTransport();
void CreateSrtpSessions();
- void OnRtpPacketReceived(const rtc::ReceivedPacket& packet) override;
- void OnRtcpPacketReceived(const rtc::ReceivedPacket& packet) override;
+ void OnRtpPacketReceived(const ReceivedIpPacket& packet) override;
+ void OnRtcpPacketReceived(const ReceivedIpPacket& packet) override;
void OnNetworkRouteChanged(
std::optional<NetworkRoute> network_route) override;
// Override the RtpTransport::OnWritableState.
void OnWritableState(PacketTransportInternal* packet_transport) override;
- bool ProtectRtp(rtc::CopyOnWriteBuffer& buffer);
+ bool ProtectRtp(CopyOnWriteBuffer& buffer);
// Overloaded version, outputs packet index.
- bool ProtectRtp(rtc::CopyOnWriteBuffer& buffer, int64_t* index);
- bool ProtectRtcp(rtc::CopyOnWriteBuffer& buffer);
+ bool ProtectRtp(CopyOnWriteBuffer& buffer, int64_t* index);
+ bool ProtectRtcp(CopyOnWriteBuffer& buffer);
// Decrypts/verifies an invidiual RTP/RTCP packet.
// If an HMAC is used, this will decrease the packet size.
- bool UnprotectRtp(rtc::CopyOnWriteBuffer& buffer);
- bool UnprotectRtcp(rtc::CopyOnWriteBuffer& buffer);
+ bool UnprotectRtp(CopyOnWriteBuffer& buffer);
+ bool UnprotectRtcp(CopyOnWriteBuffer& buffer);
const std::string content_name_;
@@ -141,8 +141,8 @@
std::optional<int> send_crypto_suite_;
std::optional<int> recv_crypto_suite_;
- rtc::ZeroOnFreeBuffer<uint8_t> send_key_;
- rtc::ZeroOnFreeBuffer<uint8_t> recv_key_;
+ ZeroOnFreeBuffer<uint8_t> send_key_;
+ ZeroOnFreeBuffer<uint8_t> recv_key_;
bool writable_ = false;
diff --git a/pc/srtp_transport_unittest.cc b/pc/srtp_transport_unittest.cc
index 77b0a65..9155832 100644
--- a/pc/srtp_transport_unittest.cc
+++ b/pc/srtp_transport_unittest.cc
@@ -39,14 +39,14 @@
namespace webrtc {
// 128 bits key + 96 bits salt.
-static const rtc::ZeroOnFreeBuffer<uint8_t> kTestKeyGcm128_1{
+static const ZeroOnFreeBuffer<uint8_t> kTestKeyGcm128_1{
"ABCDEFGHIJKLMNOPQRSTUVWXYZ12", 28};
-static const rtc::ZeroOnFreeBuffer<uint8_t> kTestKeyGcm128_2{
+static const ZeroOnFreeBuffer<uint8_t> kTestKeyGcm128_2{
"21ZYXWVUTSRQPONMLKJIHGFEDCBA", 28};
// 256 bits key + 96 bits salt.
-static const rtc::ZeroOnFreeBuffer<uint8_t> kTestKeyGcm256_1{
+static const ZeroOnFreeBuffer<uint8_t> kTestKeyGcm256_1{
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqr", 44};
-static const rtc::ZeroOnFreeBuffer<uint8_t> kTestKeyGcm256_2{
+static const ZeroOnFreeBuffer<uint8_t> kTestKeyGcm256_2{
"rqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA", 44};
class SrtpTransportTest : public ::testing::Test, public sigslot::has_slots<> {
@@ -72,13 +72,11 @@
srtp_transport2_->SetRtpPacketTransport(rtp_packet_transport2_.get());
srtp_transport1_->SubscribeRtcpPacketReceived(
- &rtp_sink1_,
- [this](rtc::CopyOnWriteBuffer* buffer, int64_t packet_time_ms) {
+ &rtp_sink1_, [this](CopyOnWriteBuffer* buffer, int64_t packet_time_ms) {
rtp_sink1_.OnRtcpPacketReceived(buffer, packet_time_ms);
});
srtp_transport2_->SubscribeRtcpPacketReceived(
- &rtp_sink2_,
- [this](rtc::CopyOnWriteBuffer* buffer, int64_t packet_time_ms) {
+ &rtp_sink2_, [this](CopyOnWriteBuffer* buffer, int64_t packet_time_ms) {
rtp_sink2_.OnRtcpPacketReceived(buffer, packet_time_ms);
});
@@ -130,26 +128,24 @@
void TestSendRecvRtpPacket(int crypto_suite) {
size_t rtp_len = sizeof(kPcmuFrame);
size_t packet_size = rtp_len + rtp_auth_tag_len(crypto_suite);
- rtc::Buffer rtp_packet_buffer(packet_size);
+ Buffer rtp_packet_buffer(packet_size);
char* rtp_packet_data = rtp_packet_buffer.data<char>();
memcpy(rtp_packet_data, kPcmuFrame, rtp_len);
// In order to be able to run this test function multiple times we can not
// use the same sequence number twice. Increase the sequence number by one.
SetBE16(reinterpret_cast<uint8_t*>(rtp_packet_data) + 2,
++sequence_number_);
- rtc::CopyOnWriteBuffer rtp_packet1to2(rtp_packet_data, rtp_len,
- packet_size);
- rtc::CopyOnWriteBuffer rtp_packet2to1(rtp_packet_data, rtp_len,
- packet_size);
+ CopyOnWriteBuffer rtp_packet1to2(rtp_packet_data, rtp_len, packet_size);
+ CopyOnWriteBuffer rtp_packet2to1(rtp_packet_data, rtp_len, packet_size);
char original_rtp_data[sizeof(kPcmuFrame)];
memcpy(original_rtp_data, rtp_packet_data, rtp_len);
- rtc::PacketOptions options;
+ AsyncSocketPacketOptions options;
// Send a packet from `srtp_transport1_` to `srtp_transport2_` and verify
// that the packet can be successfully received and decrypted.
ASSERT_TRUE(srtp_transport1_->SendRtpPacket(&rtp_packet1to2, options,
- cricket::PF_SRTP_BYPASS));
+ PF_SRTP_BYPASS));
if (srtp_transport1_->IsExternalAuthActive()) {
TestRtpAuthParams(srtp_transport1_.get(), crypto_suite);
} else {
@@ -166,7 +162,7 @@
// Do the same thing in the opposite direction;
ASSERT_TRUE(srtp_transport2_->SendRtpPacket(&rtp_packet2to1, options,
- cricket::PF_SRTP_BYPASS));
+ PF_SRTP_BYPASS));
if (srtp_transport2_->IsExternalAuthActive()) {
TestRtpAuthParams(srtp_transport2_.get(), crypto_suite);
} else {
@@ -183,20 +179,18 @@
void TestSendRecvRtcpPacket(int crypto_suite) {
size_t rtcp_len = sizeof(::kRtcpReport);
size_t packet_size = rtcp_len + 4 + rtcp_auth_tag_len(crypto_suite);
- rtc::Buffer rtcp_packet_buffer(packet_size);
+ Buffer rtcp_packet_buffer(packet_size);
char* rtcp_packet_data = rtcp_packet_buffer.data<char>();
memcpy(rtcp_packet_data, ::kRtcpReport, rtcp_len);
- rtc::CopyOnWriteBuffer rtcp_packet1to2(rtcp_packet_data, rtcp_len,
- packet_size);
- rtc::CopyOnWriteBuffer rtcp_packet2to1(rtcp_packet_data, rtcp_len,
- packet_size);
+ CopyOnWriteBuffer rtcp_packet1to2(rtcp_packet_data, rtcp_len, packet_size);
+ CopyOnWriteBuffer rtcp_packet2to1(rtcp_packet_data, rtcp_len, packet_size);
- rtc::PacketOptions options;
+ AsyncSocketPacketOptions options;
// Send a packet from `srtp_transport1_` to `srtp_transport2_` and verify
// that the packet can be successfully received and decrypted.
ASSERT_TRUE(srtp_transport1_->SendRtcpPacket(&rtcp_packet1to2, options,
- cricket::PF_SRTP_BYPASS));
+ PF_SRTP_BYPASS));
ASSERT_TRUE(rtp_sink2_.last_recv_rtcp_packet().data());
EXPECT_EQ(0, memcmp(rtp_sink2_.last_recv_rtcp_packet().data(),
rtcp_packet_data, rtcp_len));
@@ -209,7 +203,7 @@
// Do the same thing in the opposite direction;
ASSERT_TRUE(srtp_transport2_->SendRtcpPacket(&rtcp_packet2to1, options,
- cricket::PF_SRTP_BYPASS));
+ PF_SRTP_BYPASS));
ASSERT_TRUE(rtp_sink1_.last_recv_rtcp_packet().data());
EXPECT_EQ(0, memcmp(rtp_sink1_.last_recv_rtcp_packet().data(),
rtcp_packet_data, rtcp_len));
@@ -221,8 +215,8 @@
void TestSendRecvPacket(bool enable_external_auth,
int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key1,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key2) {
+ const ZeroOnFreeBuffer<uint8_t>& key1,
+ const ZeroOnFreeBuffer<uint8_t>& key2) {
EXPECT_EQ(key1.size(), key2.size());
if (enable_external_auth) {
srtp_transport1_->EnableExternalAuth();
@@ -255,26 +249,24 @@
const std::vector<int>& encrypted_header_ids) {
size_t rtp_len = sizeof(kPcmuFrameWithExtensions);
size_t packet_size = rtp_len + rtp_auth_tag_len(crypto_suite);
- rtc::Buffer rtp_packet_buffer(packet_size);
+ Buffer rtp_packet_buffer(packet_size);
char* rtp_packet_data = rtp_packet_buffer.data<char>();
memcpy(rtp_packet_data, kPcmuFrameWithExtensions, rtp_len);
// In order to be able to run this test function multiple times we can not
// use the same sequence number twice. Increase the sequence number by one.
SetBE16(reinterpret_cast<uint8_t*>(rtp_packet_data) + 2,
++sequence_number_);
- rtc::CopyOnWriteBuffer rtp_packet1to2(rtp_packet_data, rtp_len,
- packet_size);
- rtc::CopyOnWriteBuffer rtp_packet2to1(rtp_packet_data, rtp_len,
- packet_size);
+ CopyOnWriteBuffer rtp_packet1to2(rtp_packet_data, rtp_len, packet_size);
+ CopyOnWriteBuffer rtp_packet2to1(rtp_packet_data, rtp_len, packet_size);
char original_rtp_data[sizeof(kPcmuFrameWithExtensions)];
memcpy(original_rtp_data, rtp_packet_data, rtp_len);
- rtc::PacketOptions options;
+ AsyncSocketPacketOptions options;
// Send a packet from `srtp_transport1_` to `srtp_transport2_` and verify
// that the packet can be successfully received and decrypted.
ASSERT_TRUE(srtp_transport1_->SendRtpPacket(&rtp_packet1to2, options,
- cricket::PF_SRTP_BYPASS));
+ PF_SRTP_BYPASS));
ASSERT_TRUE(rtp_sink2_.last_recv_rtp_packet().data());
EXPECT_EQ(0, memcmp(rtp_sink2_.last_recv_rtp_packet().data(),
original_rtp_data, rtp_len));
@@ -292,7 +284,7 @@
// Do the same thing in the opposite direction;
ASSERT_TRUE(srtp_transport2_->SendRtpPacket(&rtp_packet2to1, options,
- cricket::PF_SRTP_BYPASS));
+ PF_SRTP_BYPASS));
ASSERT_TRUE(rtp_sink1_.last_recv_rtp_packet().data());
EXPECT_EQ(0, memcmp(rtp_sink1_.last_recv_rtp_packet().data(),
original_rtp_data, rtp_len));
@@ -309,8 +301,8 @@
void TestSendRecvEncryptedHeaderExtension(
int crypto_suite,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key1,
- const rtc::ZeroOnFreeBuffer<uint8_t>& key2) {
+ const ZeroOnFreeBuffer<uint8_t>& key1,
+ const ZeroOnFreeBuffer<uint8_t>& key2) {
std::vector<int> encrypted_headers;
encrypted_headers.push_back(kHeaderExtensionIDs[0]);
// Don't encrypt header ids 2 and 3.
@@ -409,15 +401,15 @@
std::vector<int> extension_ids;
EXPECT_FALSE(srtp_transport1_->SetRtpParams(
kSrtpAes128CmSha1_80,
- rtc::ZeroOnFreeBuffer<uint8_t>(kTestKey1.data(), kTestKey1.size() - 1),
+ ZeroOnFreeBuffer<uint8_t>(kTestKey1.data(), kTestKey1.size() - 1),
extension_ids, kSrtpAes128CmSha1_80,
- rtc::ZeroOnFreeBuffer<uint8_t>(kTestKey1.data(), kTestKey1.size() - 1),
+ ZeroOnFreeBuffer<uint8_t>(kTestKey1.data(), kTestKey1.size() - 1),
extension_ids));
EXPECT_FALSE(srtp_transport1_->SetRtcpParams(
kSrtpAes128CmSha1_80,
- rtc::ZeroOnFreeBuffer<uint8_t>(kTestKey1.data(), kTestKey1.size() - 1),
+ ZeroOnFreeBuffer<uint8_t>(kTestKey1.data(), kTestKey1.size() - 1),
extension_ids, kSrtpAes128CmSha1_80,
- rtc::ZeroOnFreeBuffer<uint8_t>(kTestKey1.data(), kTestKey1.size() - 1),
+ ZeroOnFreeBuffer<uint8_t>(kTestKey1.data(), kTestKey1.size() - 1),
extension_ids));
}
@@ -449,22 +441,22 @@
// Create a packet and try to send it three times.
size_t rtp_len = sizeof(kPcmuFrame);
size_t packet_size = rtp_len + rtp_auth_tag_len(kSrtpAeadAes128Gcm);
- rtc::Buffer rtp_packet_buffer(packet_size);
+ Buffer rtp_packet_buffer(packet_size);
char* rtp_packet_data = rtp_packet_buffer.data<char>();
memcpy(rtp_packet_data, kPcmuFrame, rtp_len);
// First attempt will succeed.
- rtc::CopyOnWriteBuffer first_try(rtp_packet_data, rtp_len, packet_size);
- EXPECT_TRUE(srtp_transport->SendRtpPacket(&first_try, rtc::PacketOptions(),
- cricket::PF_SRTP_BYPASS));
+ CopyOnWriteBuffer first_try(rtp_packet_data, rtp_len, packet_size);
+ EXPECT_TRUE(srtp_transport->SendRtpPacket(
+ &first_try, AsyncSocketPacketOptions(), PF_SRTP_BYPASS));
EXPECT_EQ(rtp_sink.rtp_count(), 1);
// Second attempt will be rejected by libSRTP as a replay attack
// (srtp_err_status_replay_fail) since the sequence number was already seen.
// Hence the packet never reaches the sink.
- rtc::CopyOnWriteBuffer second_try(rtp_packet_data, rtp_len, packet_size);
- EXPECT_TRUE(srtp_transport->SendRtpPacket(&second_try, rtc::PacketOptions(),
- cricket::PF_SRTP_BYPASS));
+ CopyOnWriteBuffer second_try(rtp_packet_data, rtp_len, packet_size);
+ EXPECT_TRUE(srtp_transport->SendRtpPacket(
+ &second_try, AsyncSocketPacketOptions(), PF_SRTP_BYPASS));
EXPECT_EQ(rtp_sink.rtp_count(), 1);
// Reset the sink.
@@ -474,9 +466,9 @@
// Third attempt will succeed again since libSRTP does not remember seeing
// the sequence number after the reset.
- rtc::CopyOnWriteBuffer third_try(rtp_packet_data, rtp_len, packet_size);
- EXPECT_TRUE(srtp_transport->SendRtpPacket(&third_try, rtc::PacketOptions(),
- cricket::PF_SRTP_BYPASS));
+ CopyOnWriteBuffer third_try(rtp_packet_data, rtp_len, packet_size);
+ EXPECT_TRUE(srtp_transport->SendRtpPacket(
+ &third_try, AsyncSocketPacketOptions(), PF_SRTP_BYPASS));
EXPECT_EQ(rtp_sink.rtp_count(), 2);
// Clear the sink to clean up.
srtp_transport->UnregisterRtpDemuxerSink(&rtp_sink);
diff --git a/pc/stream_collection.h b/pc/stream_collection.h
index f0f3f07..d417b77 100644
--- a/pc/stream_collection.h
+++ b/pc/stream_collection.h
@@ -22,13 +22,12 @@
// Implementation of StreamCollection.
class StreamCollection : public StreamCollectionInterface {
public:
- static rtc::scoped_refptr<StreamCollection> Create() {
- return rtc::make_ref_counted<StreamCollection>();
+ static scoped_refptr<StreamCollection> Create() {
+ return make_ref_counted<StreamCollection>();
}
- static rtc::scoped_refptr<StreamCollection> Create(
- StreamCollection* streams) {
- return rtc::make_ref_counted<StreamCollection>(streams);
+ static scoped_refptr<StreamCollection> Create(StreamCollection* streams) {
+ return make_ref_counted<StreamCollection>(streams);
}
virtual size_t count() { return media_streams_.size(); }
@@ -69,7 +68,7 @@
return NULL;
}
- void AddStream(rtc::scoped_refptr<MediaStreamInterface> stream) {
+ void AddStream(scoped_refptr<MediaStreamInterface> stream) {
for (StreamVector::iterator it = media_streams_.begin();
it != media_streams_.end(); ++it) {
if ((*it)->id().compare(stream->id()) == 0)
@@ -92,7 +91,7 @@
StreamCollection() {}
explicit StreamCollection(StreamCollection* original)
: media_streams_(original->media_streams_) {}
- typedef std::vector<rtc::scoped_refptr<MediaStreamInterface> > StreamVector;
+ typedef std::vector<scoped_refptr<MediaStreamInterface> > StreamVector;
StreamVector media_streams_;
};
diff --git a/pc/test/android_test_initializer.cc b/pc/test/android_test_initializer.cc
index 88b4587..db180ac 100644
--- a/pc/test/android_test_initializer.cc
+++ b/pc/test/android_test_initializer.cc
@@ -37,7 +37,7 @@
JavaVM* jvm = NULL;
RTC_CHECK_EQ(0, jni->GetJavaVM(&jvm));
- RTC_CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()";
+ RTC_CHECK(webrtc::InitializeSSL()) << "Failed to InitializeSSL()";
JVM::Initialize(jvm);
}
diff --git a/pc/test/fake_audio_capture_module.cc b/pc/test/fake_audio_capture_module.cc
index fc5e2ea..b9e42947 100644
--- a/pc/test/fake_audio_capture_module.cc
+++ b/pc/test/fake_audio_capture_module.cc
@@ -58,8 +58,8 @@
}
}
-rtc::scoped_refptr<FakeAudioCaptureModule> FakeAudioCaptureModule::Create() {
- auto capture_module = rtc::make_ref_counted<FakeAudioCaptureModule>();
+webrtc::scoped_refptr<FakeAudioCaptureModule> FakeAudioCaptureModule::Create() {
+ auto capture_module = webrtc::make_ref_counted<FakeAudioCaptureModule>();
if (!capture_module->Initialize()) {
return nullptr;
}
diff --git a/pc/test/fake_audio_capture_module.h b/pc/test/fake_audio_capture_module.h
index bead09b..b5b1574 100644
--- a/pc/test/fake_audio_capture_module.h
+++ b/pc/test/fake_audio_capture_module.h
@@ -44,7 +44,7 @@
static const size_t kNumberBytesPerSample = sizeof(Sample);
// Creates a FakeAudioCaptureModule or returns NULL on failure.
- static rtc::scoped_refptr<FakeAudioCaptureModule> Create();
+ static webrtc::scoped_refptr<FakeAudioCaptureModule> Create();
// Returns the number of frames that have been successfully pulled by the
// instance. Note that correctly detecting success can only be done if the
diff --git a/pc/test/fake_audio_capture_module_unittest.cc b/pc/test/fake_audio_capture_module_unittest.cc
index 828dff7..8a81e88 100644
--- a/pc/test/fake_audio_capture_module_unittest.cc
+++ b/pc/test/fake_audio_capture_module_unittest.cc
@@ -105,7 +105,7 @@
return pull_iterations_;
}
- rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
+ webrtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
private:
bool RecordedDataReceived() const { return rec_buffer_bytes_ != 0; }
diff --git a/pc/test/fake_data_channel_controller.h b/pc/test/fake_data_channel_controller.h
index ac70aea..1fa865c 100644
--- a/pc/test/fake_data_channel_controller.h
+++ b/pc/test/fake_data_channel_controller.h
@@ -55,10 +55,10 @@
return weak_factory_.GetWeakPtr();
}
- rtc::scoped_refptr<webrtc::SctpDataChannel> CreateDataChannel(
+ webrtc::scoped_refptr<webrtc::SctpDataChannel> CreateDataChannel(
absl::string_view label,
webrtc::InternalDataChannelInit init) {
- rtc::scoped_refptr<webrtc::SctpDataChannel> channel =
+ webrtc::scoped_refptr<webrtc::SctpDataChannel> channel =
network_thread_->BlockingCall([&]() {
RTC_DCHECK_RUN_ON(network_thread_);
webrtc::WeakPtr<FakeDataChannelController> my_weak_ptr = weak_ptr();
@@ -67,7 +67,7 @@
// thread.
RTC_CHECK(my_weak_ptr);
- rtc::scoped_refptr<webrtc::SctpDataChannel> channel =
+ webrtc::scoped_refptr<webrtc::SctpDataChannel> channel =
webrtc::SctpDataChannel::Create(
std::move(my_weak_ptr), std::string(label),
transport_available_, init, signaling_thread_,
@@ -91,7 +91,7 @@
webrtc::RTCError SendData(webrtc::StreamId sid,
const webrtc::SendDataParams& params,
- const rtc::CopyOnWriteBuffer& payload) override {
+ const webrtc::CopyOnWriteBuffer& payload) override {
RTC_DCHECK_RUN_ON(network_thread_);
RTC_CHECK(ready_to_send_);
RTC_CHECK(transport_available_);
diff --git a/pc/test/fake_peer_connection_base.h b/pc/test/fake_peer_connection_base.h
index 96a054d..10e54ca 100644
--- a/pc/test/fake_peer_connection_base.h
+++ b/pc/test/fake_peer_connection_base.h
@@ -75,11 +75,11 @@
public:
// PeerConnectionInterface implementation.
- rtc::scoped_refptr<StreamCollectionInterface> local_streams() override {
+ scoped_refptr<StreamCollectionInterface> local_streams() override {
return nullptr;
}
- rtc::scoped_refptr<StreamCollectionInterface> remote_streams() override {
+ scoped_refptr<StreamCollectionInterface> remote_streams() override {
return nullptr;
}
@@ -87,63 +87,62 @@
void RemoveStream(MediaStreamInterface* stream) override {}
- RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ RTCErrorOr<scoped_refptr<RtpSenderInterface>> AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
}
- RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ RTCErrorOr<scoped_refptr<RtpSenderInterface>> AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::vector<RtpEncodingParameters>& init_send_encodings) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
}
RTCError RemoveTrackOrError(
- rtc::scoped_refptr<RtpSenderInterface> sender) override {
+ scoped_refptr<RtpSenderInterface> sender) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION);
}
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
- rtc::scoped_refptr<MediaStreamTrackInterface> track) override {
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+ scoped_refptr<MediaStreamTrackInterface> track) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
}
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+ scoped_refptr<MediaStreamTrackInterface> track,
const RtpTransceiverInit& init) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
}
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
webrtc::MediaType media_type) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
}
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
webrtc::MediaType media_type,
const RtpTransceiverInit& init) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
}
- rtc::scoped_refptr<RtpSenderInterface> CreateSender(
+ scoped_refptr<RtpSenderInterface> CreateSender(
const std::string& kind,
const std::string& stream_id) override {
return nullptr;
}
- std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders()
+ std::vector<scoped_refptr<RtpSenderInterface>> GetSenders() const override {
+ return {};
+ }
+
+ std::vector<scoped_refptr<RtpReceiverInterface>> GetReceivers()
const override {
return {};
}
- std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers()
- const override {
- return {};
- }
-
- std::vector<rtc::scoped_refptr<RtpTransceiverInterface>> GetTransceivers()
+ std::vector<scoped_refptr<RtpTransceiverInterface>> GetTransceivers()
const override {
return {};
}
@@ -155,20 +154,18 @@
}
void GetStats(RTCStatsCollectorCallback* callback) override {}
- void GetStats(
- rtc::scoped_refptr<RtpSenderInterface> selector,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback) override {}
- void GetStats(
- rtc::scoped_refptr<RtpReceiverInterface> selector,
- rtc::scoped_refptr<RTCStatsCollectorCallback> callback) override {}
+ void GetStats(scoped_refptr<RtpSenderInterface> selector,
+ scoped_refptr<RTCStatsCollectorCallback> callback) override {}
+ void GetStats(scoped_refptr<RtpReceiverInterface> selector,
+ scoped_refptr<RTCStatsCollectorCallback> callback) override {}
void ClearStatsCache() override {}
- rtc::scoped_refptr<SctpTransportInterface> GetSctpTransport() const {
+ scoped_refptr<SctpTransportInterface> GetSctpTransport() const {
return nullptr;
}
- RTCErrorOr<rtc::scoped_refptr<DataChannelInterface>> CreateDataChannelOrError(
+ RTCErrorOr<scoped_refptr<DataChannelInterface>> CreateDataChannelOrError(
const std::string& label,
const DataChannelInit* config) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION,
@@ -216,8 +213,7 @@
void SetRemoteDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
- rtc::scoped_refptr<SetRemoteDescriptionObserverInterface> observer)
- override {}
+ scoped_refptr<SetRemoteDescriptionObserverInterface> observer) override {}
bool ShouldFireNegotiationNeededEvent(uint32_t event_id) { return true; }
@@ -247,7 +243,7 @@
void SetAudioRecording(bool recording) override {}
- rtc::scoped_refptr<DtlsTransportInterface> LookupDtlsTransportByMid(
+ scoped_refptr<DtlsTransportInterface> LookupDtlsTransportByMid(
const std::string& mid) {
return nullptr;
}
@@ -272,7 +268,7 @@
std::optional<bool> can_trickle_ice_candidates() { return std::nullopt; }
- void AddAdaptationResource(rtc::scoped_refptr<Resource> resource) {}
+ void AddAdaptationResource(scoped_refptr<Resource> resource) {}
bool StartRtcEventLog(std::unique_ptr<RtcEventLogOutput> output,
int64_t output_period_ms) override {
@@ -300,8 +296,7 @@
bool initial_offerer() const override { return false; }
- std::vector<
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
+ std::vector<scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
GetTransceiversInternal() const override {
return {};
}
@@ -325,7 +320,7 @@
bool GetLocalCertificate(
const std::string& transport_name,
- rtc::scoped_refptr<RTCCertificate>* certificate) override {
+ scoped_refptr<RTCCertificate>* certificate) override {
return false;
}
@@ -365,7 +360,7 @@
JsepTransportController* transport_controller_s() override { return nullptr; }
JsepTransportController* transport_controller_n() override { return nullptr; }
DataChannelController* data_channel_controller() override { return nullptr; }
- cricket::PortAllocator* port_allocator() override { return nullptr; }
+ PortAllocator* port_allocator() override { return nullptr; }
LegacyStatsCollector* legacy_stats() override { return nullptr; }
PeerConnectionObserver* Observer() const override { return nullptr; }
std::optional<SSLRole> GetSctpSslRole_n() override { return std::nullopt; }
@@ -378,16 +373,15 @@
void NoteUsageEvent(UsageEvent event) override {}
bool IsClosed() const override { return false; }
bool IsUnifiedPlan() const override { return true; }
- bool ValidateBundleSettings(
- const cricket::SessionDescription* desc,
- const std::map<std::string, const cricket::ContentGroup*>&
- bundle_groups_by_mid) override {
+ bool ValidateBundleSettings(const SessionDescription* desc,
+ const std::map<std::string, const ContentGroup*>&
+ bundle_groups_by_mid) override {
return false;
}
- RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+ RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
webrtc::MediaType media_type,
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ scoped_refptr<MediaStreamTrackInterface> track,
const RtpTransceiverInit& init,
bool fire_callback = true) override {
return RTCError(RTCErrorType::INTERNAL_ERROR, "");
@@ -416,9 +410,7 @@
return payload_type_picker_;
}
- cricket::CandidateStatsList GetPooledCandidateStats() const override {
- return {};
- }
+ CandidateStatsList GetPooledCandidateStats() const override { return {}; }
protected:
test::ScopedKeyValueConfig field_trials_;
@@ -426,7 +418,7 @@
};
static_assert(
- !std::is_abstract_v<rtc::RefCountedObject<FakePeerConnectionBase>>,
+ !std::is_abstract_v<webrtc::RefCountedObject<FakePeerConnectionBase>>,
"");
} // namespace webrtc
diff --git a/pc/test/fake_peer_connection_for_stats.h b/pc/test/fake_peer_connection_for_stats.h
index 0691f06f..809b03e 100644
--- a/pc/test/fake_peer_connection_for_stats.h
+++ b/pc/test/fake_peer_connection_for_stats.h
@@ -62,12 +62,10 @@
namespace webrtc {
// Fake VoiceMediaChannel where the result of GetStats can be configured.
-class FakeVoiceMediaSendChannelForStats
- : public cricket::FakeVoiceMediaSendChannel {
+class FakeVoiceMediaSendChannelForStats : public FakeVoiceMediaSendChannel {
public:
explicit FakeVoiceMediaSendChannelForStats(TaskQueueBase* network_thread)
- : cricket::FakeVoiceMediaSendChannel(cricket::AudioOptions(),
- network_thread) {}
+ : FakeVoiceMediaSendChannel(AudioOptions(), network_thread) {}
void SetStats(const VoiceMediaInfo& voice_info) {
send_stats_ = VoiceMediaSendInfo();
@@ -89,11 +87,10 @@
};
class FakeVoiceMediaReceiveChannelForStats
- : public cricket::FakeVoiceMediaReceiveChannel {
+ : public FakeVoiceMediaReceiveChannel {
public:
explicit FakeVoiceMediaReceiveChannelForStats(TaskQueueBase* network_thread)
- : cricket::FakeVoiceMediaReceiveChannel(cricket::AudioOptions(),
- network_thread) {}
+ : FakeVoiceMediaReceiveChannel(AudioOptions(), network_thread) {}
void SetStats(const VoiceMediaInfo& voice_info) {
receive_stats_ = VoiceMediaReceiveInfo();
@@ -117,11 +114,10 @@
};
// Fake VideoMediaChannel where the result of GetStats can be configured.
-class FakeVideoMediaSendChannelForStats
- : public cricket::FakeVideoMediaSendChannel {
+class FakeVideoMediaSendChannelForStats : public FakeVideoMediaSendChannel {
public:
explicit FakeVideoMediaSendChannelForStats(TaskQueueBase* network_thread)
- : cricket::FakeVideoMediaSendChannel(VideoOptions(), network_thread) {}
+ : FakeVideoMediaSendChannel(VideoOptions(), network_thread) {}
void SetStats(const VideoMediaInfo& video_info) {
send_stats_ = VideoMediaSendInfo();
@@ -144,10 +140,10 @@
};
class FakeVideoMediaReceiveChannelForStats
- : public cricket::FakeVideoMediaReceiveChannel {
+ : public FakeVideoMediaReceiveChannel {
public:
explicit FakeVideoMediaReceiveChannelForStats(TaskQueueBase* network_thread)
- : cricket::FakeVideoMediaReceiveChannel(VideoOptions(), network_thread) {}
+ : FakeVideoMediaReceiveChannel(VideoOptions(), network_thread) {}
void SetStats(const VideoMediaInfo& video_info) {
receive_stats_ = VideoMediaReceiveInfo();
@@ -171,7 +167,7 @@
constexpr bool kDefaultRtcpMuxRequired = true;
constexpr bool kDefaultSrtpRequired = true;
-class VoiceChannelForTesting : public cricket::VoiceChannel {
+class VoiceChannelForTesting : public VoiceChannel {
public:
VoiceChannelForTesting(
Thread* worker_thread,
@@ -182,7 +178,7 @@
const std::string& content_name,
bool srtp_required,
CryptoOptions crypto_options,
- rtc::UniqueRandomIdGenerator* ssrc_generator,
+ UniqueRandomIdGenerator* ssrc_generator,
std::string transport_name)
: VoiceChannel(worker_thread,
network_thread,
@@ -203,7 +199,7 @@
const std::string test_transport_name_;
};
-class VideoChannelForTesting : public cricket::VideoChannel {
+class VideoChannelForTesting : public VideoChannel {
public:
VideoChannelForTesting(
Thread* worker_thread,
@@ -214,7 +210,7 @@
const std::string& content_name,
bool srtp_required,
CryptoOptions crypto_options,
- rtc::UniqueRandomIdGenerator* ssrc_generator,
+ UniqueRandomIdGenerator* ssrc_generator,
std::string transport_name)
: VideoChannel(worker_thread,
network_thread,
@@ -271,16 +267,16 @@
return dependencies;
}
- rtc::scoped_refptr<StreamCollection> mutable_local_streams() {
+ scoped_refptr<StreamCollection> mutable_local_streams() {
return local_streams_;
}
- rtc::scoped_refptr<StreamCollection> mutable_remote_streams() {
+ scoped_refptr<StreamCollection> mutable_remote_streams() {
return remote_streams_;
}
- rtc::scoped_refptr<RtpSenderInterface> AddSender(
- rtc::scoped_refptr<RtpSenderInternal> sender) {
+ scoped_refptr<RtpSenderInterface> AddSender(
+ scoped_refptr<RtpSenderInternal> sender) {
// TODO(steveanton): Switch tests to use RtpTransceivers directly.
auto sender_proxy = RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
signaling_thread_, sender);
@@ -290,14 +286,14 @@
return sender_proxy;
}
- void RemoveSender(rtc::scoped_refptr<RtpSenderInterface> sender) {
+ void RemoveSender(scoped_refptr<RtpSenderInterface> sender) {
GetOrCreateFirstTransceiverOfType(sender->media_type())
->internal()
->RemoveSender(sender.get());
}
- rtc::scoped_refptr<RtpReceiverInterface> AddReceiver(
- rtc::scoped_refptr<RtpReceiverInternal> receiver) {
+ scoped_refptr<RtpReceiverInterface> AddReceiver(
+ scoped_refptr<RtpReceiverInternal> receiver) {
// TODO(steveanton): Switch tests to use RtpTransceivers directly.
auto receiver_proxy =
RtpReceiverProxyWithInternal<RtpReceiverInternal>::Create(
@@ -308,7 +304,7 @@
return receiver_proxy;
}
- void RemoveReceiver(rtc::scoped_refptr<RtpReceiverInterface> receiver) {
+ void RemoveReceiver(scoped_refptr<RtpReceiverInterface> receiver) {
GetOrCreateFirstTransceiverOfType(receiver->media_type())
->internal()
->RemoveReceiver(receiver.get());
@@ -390,7 +386,7 @@
Thread::Current(), Thread::Current()));
}
- void AddSctpDataChannel(rtc::scoped_refptr<SctpDataChannel> data_channel) {
+ void AddSctpDataChannel(scoped_refptr<SctpDataChannel> data_channel) {
sctp_data_channels_.push_back(data_channel);
}
@@ -417,7 +413,7 @@
}
void SetLocalCertificate(const std::string& transport_name,
- rtc::scoped_refptr<RTCCertificate> certificate) {
+ scoped_refptr<RTCCertificate> certificate) {
local_certificates_by_transport_[transport_name] = certificate;
}
@@ -428,17 +424,16 @@
// PeerConnectionInterface overrides.
- rtc::scoped_refptr<StreamCollectionInterface> local_streams() override {
+ scoped_refptr<StreamCollectionInterface> local_streams() override {
return local_streams_;
}
- rtc::scoped_refptr<StreamCollectionInterface> remote_streams() override {
+ scoped_refptr<StreamCollectionInterface> remote_streams() override {
return remote_streams_;
}
- std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders()
- const override {
- std::vector<rtc::scoped_refptr<RtpSenderInterface>> senders;
+ std::vector<scoped_refptr<RtpSenderInterface>> GetSenders() const override {
+ std::vector<scoped_refptr<RtpSenderInterface>> senders;
for (auto transceiver : transceivers_) {
for (auto sender : transceiver->internal()->senders()) {
senders.push_back(sender);
@@ -447,9 +442,9 @@
return senders;
}
- std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers()
+ std::vector<scoped_refptr<RtpReceiverInterface>> GetReceivers()
const override {
- std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers;
+ std::vector<scoped_refptr<RtpReceiverInterface>> receivers;
for (auto transceiver : transceivers_) {
for (auto receiver : transceiver->internal()->receivers()) {
receivers.push_back(receiver);
@@ -466,8 +461,7 @@
Thread* signaling_thread() const override { return signaling_thread_; }
- std::vector<
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
+ std::vector<scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
GetTransceiversInternal() const override {
return transceivers_;
}
@@ -480,9 +474,7 @@
return stats;
}
- cricket::CandidateStatsList GetPooledCandidateStats() const override {
- return {};
- }
+ CandidateStatsList GetPooledCandidateStats() const override { return {}; }
std::map<std::string, TransportStats> GetTransportStatsByNames(
const std::set<std::string>& transport_names) override {
@@ -503,7 +495,7 @@
bool GetLocalCertificate(
const std::string& transport_name,
- rtc::scoped_refptr<RTCCertificate>* certificate) override {
+ scoped_refptr<RTCCertificate>* certificate) override {
auto it = local_certificates_by_transport_.find(transport_name);
if (it != local_certificates_by_transport_.end()) {
*certificate = it->second;
@@ -540,7 +532,7 @@
return transport_stats;
}
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+ scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
GetOrCreateFirstTransceiverOfType(webrtc::MediaType media_type) {
for (auto transceiver : transceivers_) {
if (transceiver->internal()->media_type() == media_type) {
@@ -550,12 +542,12 @@
return CreateTransceiverOfType(media_type);
}
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+ scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
CreateTransceiverOfType(webrtc::MediaType media_type) {
auto transceiver = RtpTransceiverProxyWithInternal<RtpTransceiver>::Create(
signaling_thread_,
- rtc::make_ref_counted<RtpTransceiver>(media_type, context_.get(),
- &codec_lookup_helper_));
+ make_ref_counted<RtpTransceiver>(media_type, context_.get(),
+ &codec_lookup_helper_));
transceivers_.push_back(transceiver);
return transceiver;
}
@@ -565,18 +557,17 @@
Thread* const signaling_thread_;
PeerConnectionFactoryDependencies dependencies_;
- rtc::scoped_refptr<ConnectionContext> context_;
+ scoped_refptr<ConnectionContext> context_;
- rtc::scoped_refptr<StreamCollection> local_streams_;
- rtc::scoped_refptr<StreamCollection> remote_streams_;
+ scoped_refptr<StreamCollection> local_streams_;
+ scoped_refptr<StreamCollection> remote_streams_;
- std::vector<
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
+ std::vector<scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
transceivers_;
FakeDataChannelController data_channel_controller_;
- std::vector<rtc::scoped_refptr<SctpDataChannel>> sctp_data_channels_;
+ std::vector<scoped_refptr<SctpDataChannel>> sctp_data_channels_;
std::map<std::string, TransportStats> transport_stats_by_name_;
@@ -584,7 +575,7 @@
std::optional<AudioDeviceModule::Stats> audio_device_stats_;
- std::map<std::string, rtc::scoped_refptr<RTCCertificate>>
+ std::map<std::string, scoped_refptr<RTCCertificate>>
local_certificates_by_transport_;
std::map<std::string, std::unique_ptr<SSLCertChain>>
remote_cert_chains_by_transport_;
diff --git a/pc/test/fake_periodic_video_source.h b/pc/test/fake_periodic_video_source.h
index 6a79b18..3b8a0b3 100644
--- a/pc/test/fake_periodic_video_source.h
+++ b/pc/test/fake_periodic_video_source.h
@@ -72,12 +72,12 @@
return wants_;
}
- void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override {
+ void RemoveSink(VideoSinkInterface<VideoFrame>* sink) override {
RTC_DCHECK(thread_checker_.IsCurrent());
broadcaster_.RemoveSink(sink);
}
- void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
+ void AddOrUpdateSink(VideoSinkInterface<VideoFrame>* sink,
const VideoSinkWants& wants) override {
RTC_DCHECK(thread_checker_.IsCurrent());
{
@@ -96,8 +96,8 @@
private:
SequenceChecker thread_checker_{SequenceChecker::kDetached};
- rtc::VideoBroadcaster broadcaster_;
- cricket::FakeFrameSource frame_source_;
+ VideoBroadcaster broadcaster_;
+ FakeFrameSource frame_source_;
mutable Mutex mutex_;
VideoSinkWants wants_ RTC_GUARDED_BY(&mutex_);
diff --git a/pc/test/fake_rtc_certificate_generator.h b/pc/test/fake_rtc_certificate_generator.h
index 90ae666..64879c1 100644
--- a/pc/test/fake_rtc_certificate_generator.h
+++ b/pc/test/fake_rtc_certificate_generator.h
@@ -164,7 +164,7 @@
});
}
- static rtc::scoped_refptr<webrtc::RTCCertificate> GenerateCertificate() {
+ static webrtc::scoped_refptr<webrtc::RTCCertificate> GenerateCertificate() {
switch (webrtc::KT_DEFAULT) {
case webrtc::KT_RSA:
return webrtc::RTCCertificate::FromPEM(kRsaPems[0]);
@@ -212,7 +212,7 @@
++generated_failures_;
std::move(callback)(nullptr);
} else {
- rtc::scoped_refptr<webrtc::RTCCertificate> certificate =
+ webrtc::scoped_refptr<webrtc::RTCCertificate> certificate =
webrtc::RTCCertificate::FromPEM(get_pem(key_type));
RTC_DCHECK(certificate);
++generated_certificates_;
diff --git a/pc/test/fake_video_track_renderer.h b/pc/test/fake_video_track_renderer.h
index 3362e09..b45727b 100644
--- a/pc/test/fake_video_track_renderer.h
+++ b/pc/test/fake_video_track_renderer.h
@@ -18,7 +18,7 @@
namespace webrtc {
-class FakeVideoTrackRenderer : public cricket::FakeVideoRenderer {
+class FakeVideoTrackRenderer : public FakeVideoRenderer {
public:
explicit FakeVideoTrackRenderer(VideoTrackInterface* video_track)
: video_track_(video_track) {
@@ -27,7 +27,7 @@
~FakeVideoTrackRenderer() { video_track_->RemoveSink(this); }
private:
- rtc::scoped_refptr<VideoTrackInterface> video_track_;
+ scoped_refptr<VideoTrackInterface> video_track_;
};
} // namespace webrtc
diff --git a/pc/test/fake_video_track_source.h b/pc/test/fake_video_track_source.h
index a04a25d..df56f62 100644
--- a/pc/test/fake_video_track_source.h
+++ b/pc/test/fake_video_track_source.h
@@ -24,13 +24,11 @@
// injection of frames.
class FakeVideoTrackSource : public VideoTrackSource {
public:
- static rtc::scoped_refptr<FakeVideoTrackSource> Create(bool is_screencast) {
- return rtc::make_ref_counted<FakeVideoTrackSource>(is_screencast);
+ static scoped_refptr<FakeVideoTrackSource> Create(bool is_screencast) {
+ return make_ref_counted<FakeVideoTrackSource>(is_screencast);
}
- static rtc::scoped_refptr<FakeVideoTrackSource> Create() {
- return Create(false);
- }
+ static scoped_refptr<FakeVideoTrackSource> Create() { return Create(false); }
bool is_screencast() const override { return is_screencast_; }
@@ -43,13 +41,13 @@
: VideoTrackSource(false /* remote */), is_screencast_(is_screencast) {}
~FakeVideoTrackSource() override = default;
- rtc::VideoSourceInterface<VideoFrame>* source() override {
+ VideoSourceInterface<VideoFrame>* source() override {
return &video_broadcaster_;
}
private:
const bool is_screencast_;
- rtc::VideoBroadcaster video_broadcaster_;
+ VideoBroadcaster video_broadcaster_;
};
} // namespace webrtc
diff --git a/pc/test/integration_test_helpers.h b/pc/test/integration_test_helpers.h
index 23e03f1..63ba210 100644
--- a/pc/test/integration_test_helpers.h
+++ b/pc/test/integration_test_helpers.h
@@ -339,19 +339,19 @@
ResetRtpSenderObservers();
}
- rtc::scoped_refptr<RtpSenderInterface> AddAudioTrack() {
+ scoped_refptr<RtpSenderInterface> AddAudioTrack() {
return AddTrack(CreateLocalAudioTrack());
}
- rtc::scoped_refptr<RtpSenderInterface> AddVideoTrack() {
+ scoped_refptr<RtpSenderInterface> AddVideoTrack() {
return AddTrack(CreateLocalVideoTrack());
}
- rtc::scoped_refptr<AudioTrackInterface> CreateLocalAudioTrack() {
+ scoped_refptr<AudioTrackInterface> CreateLocalAudioTrack() {
AudioOptions options;
// Disable highpass filter so that we can get all the test audio frames.
options.highpass_filter = false;
- rtc::scoped_refptr<AudioSourceInterface> source =
+ scoped_refptr<AudioSourceInterface> source =
peer_connection_factory_->CreateAudioSource(options);
// TODO(perkj): Test audio source when it is implemented. Currently audio
// always use the default input.
@@ -359,18 +359,18 @@
source.get());
}
- rtc::scoped_refptr<VideoTrackInterface> CreateLocalVideoTrack() {
+ scoped_refptr<VideoTrackInterface> CreateLocalVideoTrack() {
FakePeriodicVideoSource::Config config;
config.timestamp_offset_ms = TimeMillis();
return CreateLocalVideoTrackInternal(config);
}
- rtc::scoped_refptr<VideoTrackInterface> CreateLocalVideoTrackWithConfig(
+ scoped_refptr<VideoTrackInterface> CreateLocalVideoTrackWithConfig(
FakePeriodicVideoSource::Config config) {
return CreateLocalVideoTrackInternal(config);
}
- rtc::scoped_refptr<VideoTrackInterface> CreateLocalVideoTrackWithRotation(
+ scoped_refptr<VideoTrackInterface> CreateLocalVideoTrackWithRotation(
VideoRotation rotation) {
FakePeriodicVideoSource::Config config;
config.rotation = rotation;
@@ -378,8 +378,8 @@
return CreateLocalVideoTrackInternal(config);
}
- rtc::scoped_refptr<RtpSenderInterface> AddTrack(
- rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ scoped_refptr<RtpSenderInterface> AddTrack(
+ scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids = {}) {
EXPECT_TRUE(track);
if (!track) {
@@ -394,9 +394,9 @@
}
}
- std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceiversOfType(
+ std::vector<scoped_refptr<RtpReceiverInterface>> GetReceiversOfType(
webrtc::MediaType media_type) {
- std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers;
+ std::vector<scoped_refptr<RtpReceiverInterface>> receivers;
for (const auto& receiver : pc()->GetReceivers()) {
if (receiver->media_type() == media_type) {
receivers.push_back(receiver);
@@ -405,7 +405,7 @@
return receivers;
}
- rtc::scoped_refptr<RtpTransceiverInterface> GetFirstTransceiverOfType(
+ scoped_refptr<RtpTransceiverInterface> GetFirstTransceiverOfType(
webrtc::MediaType media_type) {
for (auto transceiver : pc()->GetTransceivers()) {
if (transceiver->receiver()->media_type() == media_type) {
@@ -448,7 +448,7 @@
return data_channels_.back().get();
}
// Return all data channels.
- std::vector<rtc::scoped_refptr<DataChannelInterface>>& data_channels() {
+ std::vector<scoped_refptr<DataChannelInterface>>& data_channels() {
return data_channels_;
}
@@ -492,9 +492,9 @@
// Returns a MockStatsObserver in a state after stats gathering finished,
// which can be used to access the gathered stats.
- rtc::scoped_refptr<MockStatsObserver> OldGetStatsForTrack(
+ scoped_refptr<MockStatsObserver> OldGetStatsForTrack(
MediaStreamTrackInterface* track) {
- auto observer = rtc::make_ref_counted<MockStatsObserver>();
+ auto observer = make_ref_counted<MockStatsObserver>();
EXPECT_TRUE(peer_connection_->GetStats(
observer.get(), nullptr,
PeerConnectionInterface::kStatsOutputLevelStandard));
@@ -505,14 +505,14 @@
}
// Version that doesn't take a track "filter", and gathers all stats.
- rtc::scoped_refptr<MockStatsObserver> OldGetStats() {
+ scoped_refptr<MockStatsObserver> OldGetStats() {
return OldGetStatsForTrack(nullptr);
}
// Synchronously gets stats and returns them. If it times out, fails the test
// and returns null.
- rtc::scoped_refptr<const RTCStatsReport> NewGetStats() {
- auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>();
+ scoped_refptr<const RTCStatsReport> NewGetStats() {
+ auto callback = make_ref_counted<MockRTCStatsCollectorCallback>();
peer_connection_->GetStats(callback.get());
EXPECT_THAT(
WaitUntil([&] { return callback->called(); }, ::testing::IsTrue()),
@@ -615,7 +615,7 @@
void ResetRtpReceiverObservers() {
rtp_receiver_observers_.clear();
- for (const rtc::scoped_refptr<RtpReceiverInterface>& receiver :
+ for (const scoped_refptr<RtpReceiverInterface>& receiver :
pc()->GetReceivers()) {
std::unique_ptr<MockRtpReceiverObserver> observer(
new MockRtpReceiverObserver(receiver->media_type()));
@@ -631,8 +631,7 @@
void ResetRtpSenderObservers() {
rtp_sender_observers_.clear();
- for (const rtc::scoped_refptr<RtpSenderInterface>& sender :
- pc()->GetSenders()) {
+ for (const scoped_refptr<RtpSenderInterface>& sender : pc()->GetSenders()) {
std::unique_ptr<MockRtpSenderObserver> observer(
new MockRtpSenderObserver(sender->media_type()));
sender->SetObserver(observer.get());
@@ -667,8 +666,7 @@
// Returns null on failure.
std::unique_ptr<SessionDescriptionInterface> CreateOfferAndWait() {
- auto observer =
- rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockCreateSessionDescriptionObserver>();
pc()->CreateOffer(observer.get(), offer_answer_options_);
return WaitForDescriptionFromObserver(observer.get());
}
@@ -688,7 +686,7 @@
}
bool SetRemoteDescription(std::unique_ptr<SessionDescriptionInterface> desc) {
- auto observer = rtc::make_ref_counted<FakeSetRemoteDescriptionObserver>();
+ auto observer = make_ref_counted<FakeSetRemoteDescriptionObserver>();
std::string sdp;
EXPECT_TRUE(desc->ToString(&sdp));
RTC_LOG(LS_INFO) << debug_name_
@@ -724,7 +722,7 @@
}
uint32_t GetCorruptionScoreCount() {
- rtc::scoped_refptr<const RTCStatsReport> report = NewGetStats();
+ scoped_refptr<const RTCStatsReport> report = NewGetStats();
auto inbound_stream_stats =
report->GetStatsOfType<RTCInboundRtpStreamStats>();
for (const auto& stat : inbound_stream_stats) {
@@ -763,7 +761,7 @@
// don't outrace the description.
bool SetLocalDescriptionAndSendSdpMessage(
std::unique_ptr<SessionDescriptionInterface> desc) {
- auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockSetSessionDescriptionObserver>();
RTC_LOG(LS_INFO) << debug_name_ << ": SetLocalDescriptionAndSendSdpMessage";
SdpType type = desc->GetType();
std::string sdp;
@@ -799,7 +797,7 @@
bool reset_decoder_factory,
bool create_media_engine);
- rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
+ scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
const PeerConnectionInterface::RTCConfiguration* config,
PeerConnectionDependencies dependencies) {
PeerConnectionInterface::RTCConfiguration modified_config;
@@ -829,16 +827,16 @@
signal_ice_candidates_ = signal;
}
- rtc::scoped_refptr<VideoTrackInterface> CreateLocalVideoTrackInternal(
+ scoped_refptr<VideoTrackInterface> CreateLocalVideoTrackInternal(
FakePeriodicVideoSource::Config config) {
// Set max frame rate to 10fps to reduce the risk of test flakiness.
// TODO(deadbeef): Do something more robust.
config.frame_interval_ms = 100;
video_track_sources_.emplace_back(
- rtc::make_ref_counted<FakePeriodicVideoTrackSource>(
- config, false /* remote */));
- rtc::scoped_refptr<VideoTrackInterface> track =
+ make_ref_counted<FakePeriodicVideoTrackSource>(config,
+ false /* remote */));
+ scoped_refptr<VideoTrackInterface> track =
peer_connection_factory_->CreateVideoTrack(video_track_sources_.back(),
CreateRandomUuid());
if (!local_video_renderer_) {
@@ -887,8 +885,7 @@
// Returns null on failure.
std::unique_ptr<SessionDescriptionInterface> CreateAnswer() {
- auto observer =
- rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+ auto observer = make_ref_counted<MockCreateSessionDescriptionObserver>();
pc()->CreateAnswer(observer.get(), offer_answer_options_);
return WaitForDescriptionFromObserver(observer.get());
}
@@ -1020,11 +1017,11 @@
EXPECT_EQ(pc()->signaling_state(), new_state);
peer_connection_signaling_state_history_.push_back(new_state);
}
- void OnAddTrack(rtc::scoped_refptr<RtpReceiverInterface> receiver,
- const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&
+ void OnAddTrack(scoped_refptr<RtpReceiverInterface> receiver,
+ const std::vector<scoped_refptr<MediaStreamInterface>>&
streams) override {
if (receiver->media_type() == webrtc::MediaType::VIDEO) {
- rtc::scoped_refptr<VideoTrackInterface> video_track(
+ scoped_refptr<VideoTrackInterface> video_track(
static_cast<VideoTrackInterface*>(receiver->track().get()));
ASSERT_TRUE(fake_video_renderers_.find(video_track->id()) ==
fake_video_renderers_.end());
@@ -1032,8 +1029,7 @@
std::make_unique<FakeVideoTrackRenderer>(video_track.get());
}
}
- void OnRemoveTrack(
- rtc::scoped_refptr<RtpReceiverInterface> receiver) override {
+ void OnRemoveTrack(scoped_refptr<RtpReceiverInterface> receiver) override {
if (receiver->media_type() == webrtc::MediaType::VIDEO) {
auto it = fake_video_renderers_.find(receiver->track()->id());
if (it != fake_video_renderers_.end()) {
@@ -1120,13 +1116,13 @@
IceCandidateErrorEvent(address, port, url, error_code, error_text);
}
void OnDataChannel(
- rtc::scoped_refptr<DataChannelInterface> data_channel) override {
+ scoped_refptr<DataChannelInterface> data_channel) override {
RTC_LOG(LS_INFO) << debug_name_ << ": OnDataChannel";
data_channels_.push_back(data_channel);
data_observers_.push_back(
std::make_unique<MockDataChannelObserver>(data_channel.get()));
}
- bool IdExists(const cricket::RtpHeaderExtensions& extensions, int id) {
+ bool IdExists(const RtpHeaderExtensions& extensions, int id) {
for (const auto& extension : extensions) {
if (extension.id == id) {
return true;
@@ -1144,11 +1140,11 @@
// Reference to the mDNS responder owned by `fake_network_manager_` after set.
FakeMdnsResponder* mdns_responder_ = nullptr;
- rtc::scoped_refptr<PeerConnectionInterface> peer_connection_;
- rtc::scoped_refptr<PeerConnectionFactoryInterface> peer_connection_factory_;
+ scoped_refptr<PeerConnectionInterface> peer_connection_;
+ scoped_refptr<PeerConnectionFactoryInterface> peer_connection_factory_;
// Needed to keep track of number of frames sent.
- rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
+ scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
// Needed to keep track of number of frames received.
std::map<std::string, std::unique_ptr<FakeVideoTrackRenderer>>
fake_video_renderers_;
@@ -1165,7 +1161,7 @@
// Store references to the video sources we've created, so that we can stop
// them, if required.
- std::vector<rtc::scoped_refptr<VideoTrackSource>> video_track_sources_;
+ std::vector<scoped_refptr<VideoTrackSource>> video_track_sources_;
// `local_video_renderer_` attached to the first created local video track.
std::unique_ptr<FakeVideoTrackRenderer> local_video_renderer_;
@@ -1182,7 +1178,7 @@
SocketAddress remote_async_dns_resolved_addr_;
// All data channels either created or observed on this peerconnection
- std::vector<rtc::scoped_refptr<DataChannelInterface>> data_channels_;
+ std::vector<scoped_refptr<DataChannelInterface>> data_channels_;
std::vector<std::unique_ptr<MockDataChannelObserver>> data_observers_;
std::vector<std::unique_ptr<MockRtpReceiverObserver>> rtp_receiver_observers_;
@@ -1348,12 +1344,12 @@
class MockIceTransportFactory : public IceTransportFactory {
public:
~MockIceTransportFactory() override = default;
- rtc::scoped_refptr<IceTransportInterface> CreateIceTransport(
+ scoped_refptr<IceTransportInterface> CreateIceTransport(
const std::string& transport_name,
int component,
IceTransportInit init) {
RecordIceTransportCreated();
- return rtc::make_ref_counted<MockIceTransport>(transport_name, component);
+ return make_ref_counted<MockIceTransport>(transport_name, component);
}
MOCK_METHOD(void, RecordIceTransportCreated, ());
};
diff --git a/pc/test/mock_channel_interface.h b/pc/test/mock_channel_interface.h
index 2fdfdd0..06a8bff 100644
--- a/pc/test/mock_channel_interface.h
+++ b/pc/test/mock_channel_interface.h
@@ -29,7 +29,7 @@
// Mock class for BaseChannel.
// Use this class in unit tests to avoid dependency on a specific
// implementation of BaseChannel.
-class MockChannelInterface : public cricket::ChannelInterface {
+class MockChannelInterface : public ChannelInterface {
public:
MOCK_METHOD(MediaType, media_type, (), (const, override));
MOCK_METHOD(VideoChannel*, AsVideoChannel, (), (override));
@@ -75,11 +75,11 @@
(const webrtc::MediaContentDescription*, SdpType, std::string&),
(override));
MOCK_METHOD(bool, SetPayloadTypeDemuxingEnabled, (bool), (override));
- MOCK_METHOD(const std::vector<cricket::StreamParams>&,
+ MOCK_METHOD(const std::vector<StreamParams>&,
local_streams,
(),
(const, override));
- MOCK_METHOD(const std::vector<cricket::StreamParams>&,
+ MOCK_METHOD(const std::vector<StreamParams>&,
remote_streams,
(),
(const, override));
diff --git a/pc/test/mock_peer_connection_internal.h b/pc/test/mock_peer_connection_internal.h
index dc236bf..a52c9a4 100644
--- a/pc/test/mock_peer_connection_internal.h
+++ b/pc/test/mock_peer_connection_internal.h
@@ -71,61 +71,61 @@
MockPeerConnectionInternal() {}
~MockPeerConnectionInternal() = default;
// PeerConnectionInterface
- MOCK_METHOD(rtc::scoped_refptr<StreamCollectionInterface>,
+ MOCK_METHOD(scoped_refptr<StreamCollectionInterface>,
local_streams,
(),
(override));
- MOCK_METHOD(rtc::scoped_refptr<StreamCollectionInterface>,
+ MOCK_METHOD(scoped_refptr<StreamCollectionInterface>,
remote_streams,
(),
(override));
MOCK_METHOD(bool, AddStream, (MediaStreamInterface*), (override));
MOCK_METHOD(void, RemoveStream, (MediaStreamInterface*), (override));
- MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>>,
+ MOCK_METHOD(RTCErrorOr<scoped_refptr<RtpSenderInterface>>,
AddTrack,
- (rtc::scoped_refptr<MediaStreamTrackInterface>,
+ (webrtc::scoped_refptr<MediaStreamTrackInterface>,
const std::vector<std::string>&),
(override));
- MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>>,
+ MOCK_METHOD(RTCErrorOr<scoped_refptr<RtpSenderInterface>>,
AddTrack,
- (rtc::scoped_refptr<MediaStreamTrackInterface>,
+ (webrtc::scoped_refptr<MediaStreamTrackInterface>,
const std::vector<std::string>&,
const std::vector<RtpEncodingParameters>&),
(override));
MOCK_METHOD(RTCError,
RemoveTrackOrError,
- (rtc::scoped_refptr<RtpSenderInterface>),
+ (webrtc::scoped_refptr<RtpSenderInterface>),
(override));
- MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>,
+ MOCK_METHOD(RTCErrorOr<scoped_refptr<RtpTransceiverInterface>>,
AddTransceiver,
- (rtc::scoped_refptr<MediaStreamTrackInterface>),
+ (webrtc::scoped_refptr<MediaStreamTrackInterface>),
(override));
- MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>,
+ MOCK_METHOD(RTCErrorOr<scoped_refptr<RtpTransceiverInterface>>,
AddTransceiver,
- (rtc::scoped_refptr<MediaStreamTrackInterface>,
+ (webrtc::scoped_refptr<MediaStreamTrackInterface>,
const RtpTransceiverInit&),
(override));
- MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>,
+ MOCK_METHOD(RTCErrorOr<scoped_refptr<RtpTransceiverInterface>>,
AddTransceiver,
(webrtc::MediaType),
(override));
- MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>,
+ MOCK_METHOD(RTCErrorOr<scoped_refptr<RtpTransceiverInterface>>,
AddTransceiver,
(webrtc::MediaType, const RtpTransceiverInit&),
(override));
- MOCK_METHOD(rtc::scoped_refptr<RtpSenderInterface>,
+ MOCK_METHOD(scoped_refptr<RtpSenderInterface>,
CreateSender,
(const std::string&, const std::string&),
(override));
- MOCK_METHOD(std::vector<rtc::scoped_refptr<RtpSenderInterface>>,
+ MOCK_METHOD(std::vector<scoped_refptr<RtpSenderInterface>>,
GetSenders,
(),
(const, override));
- MOCK_METHOD(std::vector<rtc::scoped_refptr<RtpReceiverInterface>>,
+ MOCK_METHOD(std::vector<scoped_refptr<RtpReceiverInterface>>,
GetReceivers,
(),
(const, override));
- MOCK_METHOD(std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>,
+ MOCK_METHOD(std::vector<scoped_refptr<RtpTransceiverInterface>>,
GetTransceivers,
(),
(const, override));
@@ -136,16 +136,16 @@
MOCK_METHOD(void, GetStats, (RTCStatsCollectorCallback*), (override));
MOCK_METHOD(void,
GetStats,
- (rtc::scoped_refptr<RtpSenderInterface>,
- rtc::scoped_refptr<RTCStatsCollectorCallback>),
+ (webrtc::scoped_refptr<RtpSenderInterface>,
+ webrtc::scoped_refptr<RTCStatsCollectorCallback>),
(override));
MOCK_METHOD(void,
GetStats,
- (rtc::scoped_refptr<RtpReceiverInterface>,
- rtc::scoped_refptr<RTCStatsCollectorCallback>),
+ (webrtc::scoped_refptr<RtpReceiverInterface>,
+ webrtc::scoped_refptr<RTCStatsCollectorCallback>),
(override));
MOCK_METHOD(void, ClearStatsCache, (), (override));
- MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<DataChannelInterface>>,
+ MOCK_METHOD(RTCErrorOr<scoped_refptr<DataChannelInterface>>,
CreateDataChannelOrError,
(const std::string&, const DataChannelInit*),
(override));
@@ -194,7 +194,7 @@
MOCK_METHOD(void,
SetRemoteDescription,
(std::unique_ptr<SessionDescriptionInterface>,
- rtc::scoped_refptr<SetRemoteDescriptionObserverInterface>),
+ webrtc::scoped_refptr<SetRemoteDescriptionObserverInterface>),
(override));
MOCK_METHOD(bool,
ShouldFireNegotiationNeededEvent,
@@ -214,7 +214,7 @@
(override));
MOCK_METHOD(bool,
RemoveIceCandidates,
- (const std::vector<cricket::Candidate>&),
+ (const std::vector<webrtc::Candidate>&),
(override));
MOCK_METHOD(RTCError, SetBitrate, (const BitrateSettings&), (override));
MOCK_METHOD(void,
@@ -223,11 +223,11 @@
(override));
MOCK_METHOD(void, SetAudioPlayout, (bool), (override));
MOCK_METHOD(void, SetAudioRecording, (bool), (override));
- MOCK_METHOD(rtc::scoped_refptr<DtlsTransportInterface>,
+ MOCK_METHOD(scoped_refptr<DtlsTransportInterface>,
LookupDtlsTransportByMid,
(const std::string&),
(override));
- MOCK_METHOD(rtc::scoped_refptr<SctpTransportInterface>,
+ MOCK_METHOD(scoped_refptr<SctpTransportInterface>,
GetSctpTransport,
(),
(const, override));
@@ -241,7 +241,7 @@
MOCK_METHOD(IceGatheringState, ice_gathering_state, (), (override));
MOCK_METHOD(void,
AddAdaptationResource,
- (rtc::scoped_refptr<Resource>),
+ (webrtc::scoped_refptr<Resource>),
(override));
MOCK_METHOD(std::optional<bool>, can_trickle_ice_candidates, (), (override));
MOCK_METHOD(bool,
@@ -287,7 +287,7 @@
MOCK_METHOD(JsepTransportController*, transport_controller_s, (), (override));
MOCK_METHOD(JsepTransportController*, transport_controller_n, (), (override));
MOCK_METHOD(DataChannelController*, data_channel_controller, (), (override));
- MOCK_METHOD(cricket::PortAllocator*, port_allocator, (), (override));
+ MOCK_METHOD(PortAllocator*, port_allocator, (), (override));
MOCK_METHOD(LegacyStatsCollector*, legacy_stats, (), (override));
MOCK_METHOD(PeerConnectionObserver*, Observer, (), (const, override));
MOCK_METHOD(std::optional<SSLRole>, GetSctpSslRole_n, (), (override));
@@ -304,20 +304,20 @@
MOCK_METHOD(bool, IsUnifiedPlan, (), (const, override));
MOCK_METHOD(bool,
ValidateBundleSettings,
- (const cricket::SessionDescription*,
- (const std::map<std::string, const cricket::ContentGroup*>&)),
+ (const webrtc::SessionDescription*,
+ (const std::map<std::string, const webrtc::ContentGroup*>&)),
(override));
- MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>,
+ MOCK_METHOD(RTCErrorOr<scoped_refptr<RtpTransceiverInterface>>,
AddTransceiver,
(webrtc::MediaType,
- rtc::scoped_refptr<MediaStreamTrackInterface>,
+ webrtc::scoped_refptr<MediaStreamTrackInterface>,
const RtpTransceiverInit&,
bool),
(override));
MOCK_METHOD(RTCError, StartSctpTransport, (const SctpOptions&), (override));
MOCK_METHOD(void,
AddRemoteCandidate,
- (absl::string_view, const cricket::Candidate&),
+ (absl::string_view, const webrtc::Candidate&),
(override));
MOCK_METHOD(Call*, call_ptr, (), (override));
MOCK_METHOD(bool, SrtpRequired, (), (const, override));
@@ -334,7 +334,7 @@
MOCK_METHOD(bool, initial_offerer, (), (const, override));
MOCK_METHOD(
std::vector<
- rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>,
+ scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>,
GetTransceiversInternal,
(),
(const, override));
@@ -346,11 +346,11 @@
sctp_transport_name,
(),
(const, override));
- MOCK_METHOD(cricket::CandidateStatsList,
+ MOCK_METHOD(CandidateStatsList,
GetPooledCandidateStats,
(),
(const, override));
- MOCK_METHOD((std::map<std::string, cricket::TransportStats>),
+ MOCK_METHOD((std::map<std::string, TransportStats>),
GetTransportStatsByNames,
(const std::set<std::string>&),
(override));
@@ -361,9 +361,10 @@
(override));
MOCK_METHOD(bool,
GetLocalCertificate,
- (const std::string&, rtc::scoped_refptr<rtc::RTCCertificate>*),
+ (const std::string&,
+ webrtc::scoped_refptr<webrtc::RTCCertificate>*),
(override));
- MOCK_METHOD(std::unique_ptr<rtc::SSLCertChain>,
+ MOCK_METHOD(std::unique_ptr<SSLCertChain>,
GetRemoteSSLCertChain,
(const std::string&),
(override));
diff --git a/pc/test/mock_peer_connection_observers.h b/pc/test/mock_peer_connection_observers.h
index bbf0e97..6bd7743 100644
--- a/pc/test/mock_peer_connection_observers.h
+++ b/pc/test/mock_peer_connection_observers.h
@@ -52,12 +52,12 @@
public:
struct AddTrackEvent {
explicit AddTrackEvent(
- rtc::scoped_refptr<RtpReceiverInterface> event_receiver,
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> event_streams)
+ scoped_refptr<RtpReceiverInterface> event_receiver,
+ std::vector<scoped_refptr<MediaStreamInterface>> event_streams)
: receiver(std::move(event_receiver)),
streams(std::move(event_streams)) {
for (auto stream : streams) {
- std::vector<rtc::scoped_refptr<MediaStreamTrackInterface>> tracks;
+ std::vector<scoped_refptr<MediaStreamTrackInterface>> tracks;
for (auto audio_track : stream->GetAudioTracks()) {
tracks.push_back(audio_track);
}
@@ -68,12 +68,12 @@
}
}
- rtc::scoped_refptr<RtpReceiverInterface> receiver;
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams;
+ scoped_refptr<RtpReceiverInterface> receiver;
+ std::vector<scoped_refptr<MediaStreamInterface>> streams;
// This map records the tracks present in each stream at the time the
// OnAddTrack callback was issued.
- std::map<rtc::scoped_refptr<MediaStreamInterface>,
- std::vector<rtc::scoped_refptr<MediaStreamTrackInterface>>>
+ std::map<scoped_refptr<MediaStreamInterface>,
+ std::vector<scoped_refptr<MediaStreamTrackInterface>>>
snapshotted_stream_tracks;
};
@@ -98,12 +98,11 @@
StreamCollectionInterface* remote_streams() const {
return remote_streams_.get();
}
- void OnAddStream(rtc::scoped_refptr<MediaStreamInterface> stream) override {
+ void OnAddStream(scoped_refptr<MediaStreamInterface> stream) override {
last_added_stream_ = stream;
remote_streams_->AddStream(stream);
}
- void OnRemoveStream(
- rtc::scoped_refptr<MediaStreamInterface> stream) override {
+ void OnRemoveStream(scoped_refptr<MediaStreamInterface> stream) override {
last_removed_stream_ = stream;
remote_streams_->RemoveStream(stream.get());
}
@@ -112,7 +111,7 @@
latest_negotiation_needed_event_ = event_id;
}
void OnDataChannel(
- rtc::scoped_refptr<DataChannelInterface> data_channel) override {
+ scoped_refptr<DataChannelInterface> data_channel) override {
last_datachannel_ = data_channel;
}
@@ -155,8 +154,8 @@
callback_triggered_ = true;
}
- void OnAddTrack(rtc::scoped_refptr<RtpReceiverInterface> receiver,
- const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&
+ void OnAddTrack(scoped_refptr<RtpReceiverInterface> receiver,
+ const std::vector<scoped_refptr<MediaStreamInterface>>&
streams) override {
RTC_DCHECK(receiver);
num_added_tracks_++;
@@ -164,18 +163,16 @@
add_track_events_.push_back(AddTrackEvent(receiver, streams));
}
- void OnTrack(
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver) override {
+ void OnTrack(scoped_refptr<RtpTransceiverInterface> transceiver) override {
on_track_transceivers_.push_back(transceiver);
}
- void OnRemoveTrack(
- rtc::scoped_refptr<RtpReceiverInterface> receiver) override {
+ void OnRemoveTrack(scoped_refptr<RtpReceiverInterface> receiver) override {
remove_track_events_.push_back(receiver);
}
- std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetAddTrackReceivers() {
- std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers;
+ std::vector<scoped_refptr<RtpReceiverInterface>> GetAddTrackReceivers() {
+ std::vector<scoped_refptr<RtpReceiverInterface>> receivers;
for (const AddTrackEvent& event : add_track_events_) {
receivers.push_back(event.receiver);
}
@@ -251,11 +248,11 @@
latest_negotiation_needed_event_ = std::nullopt;
}
- rtc::scoped_refptr<PeerConnectionInterface> pc_;
+ scoped_refptr<PeerConnectionInterface> pc_;
PeerConnectionInterface::SignalingState state_;
std::vector<std::unique_ptr<IceCandidateInterface>> candidates_;
- rtc::scoped_refptr<DataChannelInterface> last_datachannel_;
- rtc::scoped_refptr<StreamCollection> remote_streams_;
+ scoped_refptr<DataChannelInterface> last_datachannel_;
+ scoped_refptr<StreamCollection> remote_streams_;
bool renegotiation_needed_ = false;
std::optional<uint32_t> latest_negotiation_needed_event_;
bool ice_gathering_complete_ = false;
@@ -264,14 +261,13 @@
int num_added_tracks_ = 0;
std::string last_added_track_label_;
std::vector<AddTrackEvent> add_track_events_;
- std::vector<rtc::scoped_refptr<RtpReceiverInterface>> remove_track_events_;
- std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>
- on_track_transceivers_;
+ std::vector<scoped_refptr<RtpReceiverInterface>> remove_track_events_;
+ std::vector<scoped_refptr<RtpTransceiverInterface>> on_track_transceivers_;
int num_candidates_removed_ = 0;
private:
- rtc::scoped_refptr<MediaStreamInterface> last_added_stream_;
- rtc::scoped_refptr<MediaStreamInterface> last_removed_stream_;
+ scoped_refptr<MediaStreamInterface> last_added_stream_;
+ scoped_refptr<MediaStreamInterface> last_removed_stream_;
};
class MockCreateSessionDescriptionObserver
@@ -318,8 +314,8 @@
class MockSetSessionDescriptionObserver : public SetSessionDescriptionObserver {
public:
- static rtc::scoped_refptr<MockSetSessionDescriptionObserver> Create() {
- return rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ static scoped_refptr<MockSetSessionDescriptionObserver> Create() {
+ return make_ref_counted<MockSetSessionDescriptionObserver>();
}
MockSetSessionDescriptionObserver()
@@ -450,7 +446,7 @@
}
private:
- rtc::scoped_refptr<DataChannelInterface> channel_;
+ scoped_refptr<DataChannelInterface> channel_;
std::vector<DataChannelInterface::DataState> states_;
std::vector<Message> messages_;
std::function<void(DataChannelInterface::DataState)> state_change_callback_;
@@ -610,20 +606,20 @@
// Helper class that just stores the report from the callback.
class MockRTCStatsCollectorCallback : public RTCStatsCollectorCallback {
public:
- rtc::scoped_refptr<const RTCStatsReport> report() { return report_; }
+ scoped_refptr<const RTCStatsReport> report() { return report_; }
bool called() const { return called_; }
protected:
void OnStatsDelivered(
- const rtc::scoped_refptr<const RTCStatsReport>& report) override {
+ const scoped_refptr<const RTCStatsReport>& report) override {
report_ = report;
called_ = true;
}
private:
bool called_ = false;
- rtc::scoped_refptr<const RTCStatsReport> report_;
+ scoped_refptr<const RTCStatsReport> report_;
};
} // namespace webrtc
diff --git a/pc/test/mock_rtp_receiver_internal.h b/pc/test/mock_rtp_receiver_internal.h
index f29a736..046e7f7 100644
--- a/pc/test/mock_rtp_receiver_internal.h
+++ b/pc/test/mock_rtp_receiver_internal.h
@@ -34,16 +34,16 @@
class MockRtpReceiverInternal : public RtpReceiverInternal {
public:
// RtpReceiverInterface methods.
- MOCK_METHOD(rtc::scoped_refptr<MediaStreamTrackInterface>,
+ MOCK_METHOD(scoped_refptr<MediaStreamTrackInterface>,
track,
(),
(const, override));
- MOCK_METHOD(rtc::scoped_refptr<DtlsTransportInterface>,
+ MOCK_METHOD(scoped_refptr<DtlsTransportInterface>,
dtls_transport,
(),
(const, override));
MOCK_METHOD(std::vector<std::string>, stream_ids, (), (const, override));
- MOCK_METHOD(std::vector<rtc::scoped_refptr<MediaStreamInterface>>,
+ MOCK_METHOD(std::vector<scoped_refptr<MediaStreamInterface>>,
streams,
(),
(const, override));
@@ -58,9 +58,9 @@
MOCK_METHOD(std::vector<RtpSource>, GetSources, (), (const, override));
MOCK_METHOD(void,
SetFrameDecryptor,
- (rtc::scoped_refptr<FrameDecryptorInterface>),
+ (webrtc::scoped_refptr<FrameDecryptorInterface>),
(override));
- MOCK_METHOD(rtc::scoped_refptr<FrameDecryptorInterface>,
+ MOCK_METHOD(scoped_refptr<FrameDecryptorInterface>,
GetFrameDecryptor,
(),
(const, override));
@@ -78,11 +78,11 @@
MOCK_METHOD(void, set_stream_ids, (std::vector<std::string>), (override));
MOCK_METHOD(void,
set_transport,
- (rtc::scoped_refptr<DtlsTransportInterface>),
+ (webrtc::scoped_refptr<DtlsTransportInterface>),
(override));
MOCK_METHOD(void,
SetStreams,
- (const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&),
+ (const std::vector<webrtc::scoped_refptr<MediaStreamInterface>>&),
(override));
MOCK_METHOD(int, AttachmentId, (), (const, override));
};
diff --git a/pc/test/mock_rtp_sender_internal.h b/pc/test/mock_rtp_sender_internal.h
index 317851a..4743d7f 100644
--- a/pc/test/mock_rtp_sender_internal.h
+++ b/pc/test/mock_rtp_sender_internal.h
@@ -39,12 +39,12 @@
public:
// RtpSenderInterface methods.
MOCK_METHOD(bool, SetTrack, (MediaStreamTrackInterface*), (override));
- MOCK_METHOD(rtc::scoped_refptr<MediaStreamTrackInterface>,
+ MOCK_METHOD(scoped_refptr<MediaStreamTrackInterface>,
track,
(),
(const, override));
MOCK_METHOD(uint32_t, ssrc, (), (const, override));
- MOCK_METHOD(rtc::scoped_refptr<DtlsTransportInterface>,
+ MOCK_METHOD(scoped_refptr<DtlsTransportInterface>,
dtls_transport,
(),
(const, override));
@@ -57,7 +57,7 @@
(const, override));
MOCK_METHOD(void,
set_transport,
- (rtc::scoped_refptr<DtlsTransportInterface>),
+ (webrtc::scoped_refptr<DtlsTransportInterface>),
(override));
MOCK_METHOD(RtpParameters, GetParameters, (), (const, override));
MOCK_METHOD(RtpParameters, GetParametersInternal, (), (const, override));
@@ -84,21 +84,21 @@
(override));
MOCK_METHOD(void, SetSendCodecs, (std::vector<Codec>), (override));
MOCK_METHOD(std::vector<Codec>, GetSendCodecs, (), (const, override));
- MOCK_METHOD(rtc::scoped_refptr<DtmfSenderInterface>,
+ MOCK_METHOD(scoped_refptr<DtmfSenderInterface>,
GetDtmfSender,
(),
(const, override));
MOCK_METHOD(void,
SetFrameEncryptor,
- (rtc::scoped_refptr<FrameEncryptorInterface>),
+ (webrtc::scoped_refptr<FrameEncryptorInterface>),
(override));
- MOCK_METHOD(rtc::scoped_refptr<FrameEncryptorInterface>,
+ MOCK_METHOD(scoped_refptr<FrameEncryptorInterface>,
GetFrameEncryptor,
(),
(const, override));
MOCK_METHOD(void,
SetFrameTransformer,
- (rtc::scoped_refptr<FrameTransformerInterface>),
+ (webrtc::scoped_refptr<FrameTransformerInterface>),
(override));
MOCK_METHOD(void,
SetEncoderSelector,
diff --git a/pc/test/mock_voice_media_receive_channel_interface.h b/pc/test/mock_voice_media_receive_channel_interface.h
index f61025d..87aff5d 100644
--- a/pc/test/mock_voice_media_receive_channel_interface.h
+++ b/pc/test/mock_voice_media_receive_channel_interface.h
@@ -33,7 +33,7 @@
namespace webrtc {
class MockVoiceMediaReceiveChannelInterface
- : public cricket::VoiceMediaReceiveChannelInterface {
+ : public VoiceMediaReceiveChannelInterface {
public:
MockVoiceMediaReceiveChannelInterface() {
ON_CALL(*this, AsVoiceReceiveChannel).WillByDefault(testing::Return(this));
@@ -42,7 +42,7 @@
// VoiceMediaReceiveChannelInterface
MOCK_METHOD(bool,
SetReceiverParameters,
- (const cricket::AudioReceiverParameters& params),
+ (const webrtc::AudioReceiverParameters& params),
(override));
MOCK_METHOD(RtpParameters,
GetRtpReceiverParameters,
@@ -72,7 +72,7 @@
(override));
MOCK_METHOD(bool,
GetStats,
- (cricket::VoiceMediaReceiveInfo * stats, bool reset_legacy),
+ (webrtc::VoiceMediaReceiveInfo * stats, bool reset_legacy),
(override));
MOCK_METHOD(::webrtc::RtcpMode, RtcpMode, (), (const, override));
MOCK_METHOD(void, SetRtcpMode, (::webrtc::RtcpMode mode), (override));
@@ -80,24 +80,24 @@
MOCK_METHOD(void, SetReceiveNonSenderRttEnabled, (bool enabled), (override));
// MediaReceiveChannelInterface
- MOCK_METHOD(cricket::VideoMediaReceiveChannelInterface*,
+ MOCK_METHOD(VideoMediaReceiveChannelInterface*,
AsVideoReceiveChannel,
(),
(override));
- MOCK_METHOD(cricket::VoiceMediaReceiveChannelInterface*,
+ MOCK_METHOD(VoiceMediaReceiveChannelInterface*,
AsVoiceReceiveChannel,
(),
(override));
MOCK_METHOD(MediaType, media_type, (), (const, override));
MOCK_METHOD(bool,
AddRecvStream,
- (const cricket::StreamParams& sp),
+ (const webrtc::StreamParams& sp),
(override));
MOCK_METHOD(bool, RemoveRecvStream, (uint32_t ssrc), (override));
MOCK_METHOD(void, ResetUnsignaledRecvStream, (), (override));
MOCK_METHOD(void,
SetInterface,
- (cricket::MediaChannelNetworkInterface * iface),
+ (webrtc::MediaChannelNetworkInterface * iface),
(override));
MOCK_METHOD(void,
OnPacketReceived,
diff --git a/pc/test/peer_connection_test_wrapper.cc b/pc/test/peer_connection_test_wrapper.cc
index 95393f1..94f9b65 100644
--- a/pc/test/peer_connection_test_wrapper.cc
+++ b/pc/test/peer_connection_test_wrapper.cc
@@ -170,8 +170,8 @@
bool PeerConnectionTestWrapper::CreatePc(
const webrtc::PeerConnectionInterface::RTCConfiguration& config,
- rtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory,
- rtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory,
+ webrtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory,
+ webrtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory,
std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory,
std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory,
std::unique_ptr<webrtc::FieldTrialsView> field_trials) {
@@ -187,7 +187,8 @@
peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
network_thread_, worker_thread_, webrtc::Thread::Current(),
- rtc::scoped_refptr<webrtc::AudioDeviceModule>(fake_audio_capture_module_),
+ webrtc::scoped_refptr<webrtc::AudioDeviceModule>(
+ fake_audio_capture_module_),
audio_encoder_factory, audio_decoder_factory,
std::move(video_encoder_factory), std::move(video_decoder_factory),
nullptr /* audio_mixer */, nullptr /* audio_processing */, nullptr,
@@ -213,8 +214,8 @@
bool PeerConnectionTestWrapper::CreatePc(
const webrtc::PeerConnectionInterface::RTCConfiguration& config,
- rtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory,
- rtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory,
+ webrtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory,
+ webrtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory,
std::unique_ptr<webrtc::FieldTrialsView> field_trials) {
return CreatePc(config, std::move(audio_encoder_factory),
std::move(audio_decoder_factory),
@@ -227,7 +228,7 @@
std::move(field_trials));
}
-rtc::scoped_refptr<webrtc::DataChannelInterface>
+webrtc::scoped_refptr<webrtc::DataChannelInterface>
PeerConnectionTestWrapper::CreateDataChannel(
const std::string& label,
const webrtc::DataChannelInit& init) {
@@ -270,8 +271,8 @@
}
void PeerConnectionTestWrapper::OnAddTrack(
- rtc::scoped_refptr<RtpReceiverInterface> receiver,
- const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
+ webrtc::scoped_refptr<RtpReceiverInterface> receiver,
+ const std::vector<webrtc::scoped_refptr<MediaStreamInterface>>& streams) {
RTC_LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_ << ": OnAddTrack";
if (receiver->track()->kind() == MediaStreamTrackInterface::kVideoKind) {
auto* video_track =
@@ -289,7 +290,7 @@
}
void PeerConnectionTestWrapper::OnDataChannel(
- rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
+ webrtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
SignalOnDataChannel(data_channel.get());
}
@@ -338,7 +339,7 @@
<< ": SetLocalDescription " << webrtc::SdpTypeToString(type)
<< " " << sdp;
- auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ auto observer = webrtc::make_ref_counted<MockSetSessionDescriptionObserver>();
peer_connection_->SetLocalDescription(
observer.get(), webrtc::CreateSessionDescription(type, sdp).release());
}
@@ -349,7 +350,7 @@
<< ": SetRemoteDescription " << webrtc::SdpTypeToString(type)
<< " " << sdp;
- auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+ auto observer = webrtc::make_ref_counted<MockSetSessionDescriptionObserver>();
peer_connection_->SetRemoteDescription(
observer.get(), webrtc::CreateSessionDescription(type, sdp).release());
}
@@ -433,7 +434,7 @@
bool audio,
const webrtc::AudioOptions& audio_options,
bool video) {
- rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
+ webrtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
GetUserMedia(audio, audio_options, video);
for (const auto& audio_track : stream->GetAudioTracks()) {
EXPECT_TRUE(peer_connection_->AddTrack(audio_track, {stream->id()}).ok());
@@ -443,7 +444,7 @@
}
}
-rtc::scoped_refptr<webrtc::MediaStreamInterface>
+webrtc::scoped_refptr<webrtc::MediaStreamInterface>
PeerConnectionTestWrapper::GetUserMedia(
bool audio,
const webrtc::AudioOptions& audio_options,
@@ -451,16 +452,16 @@
webrtc::Resolution resolution) {
std::string stream_id =
kStreamIdBase + absl::StrCat(num_get_user_media_calls_++);
- rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
+ webrtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
peer_connection_factory_->CreateLocalMediaStream(stream_id);
if (audio) {
webrtc::AudioOptions options = audio_options;
// Disable highpass filter so that we can get all the test audio frames.
options.highpass_filter = false;
- rtc::scoped_refptr<webrtc::AudioSourceInterface> source =
+ webrtc::scoped_refptr<webrtc::AudioSourceInterface> source =
peer_connection_factory_->CreateAudioSource(options);
- rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
+ webrtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
peer_connection_factory_->CreateAudioTrack(kAudioTrackLabelBase,
source.get()));
stream->AddTrack(audio_track);
@@ -474,12 +475,13 @@
config.width = resolution.width;
config.height = resolution.height;
- auto source = rtc::make_ref_counted<webrtc::FakePeriodicVideoTrackSource>(
- config, /* remote */ false);
+ auto source =
+ webrtc::make_ref_counted<webrtc::FakePeriodicVideoTrackSource>(
+ config, /* remote */ false);
fake_video_sources_.push_back(source);
std::string videotrack_label = stream_id + kVideoTrackLabelBase;
- rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
+ webrtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
peer_connection_factory_->CreateVideoTrack(source, videotrack_label));
stream->AddTrack(video_track);
diff --git a/pc/test/peer_connection_test_wrapper.h b/pc/test/peer_connection_test_wrapper.h
index 7cf6f9e..30fa5c4 100644
--- a/pc/test/peer_connection_test_wrapper.h
+++ b/pc/test/peer_connection_test_wrapper.h
@@ -57,24 +57,24 @@
bool CreatePc(
const webrtc::PeerConnectionInterface::RTCConfiguration& config,
- rtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory,
- rtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory,
+ webrtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory,
+ webrtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory,
std::unique_ptr<webrtc::FieldTrialsView> field_trials = nullptr);
bool CreatePc(
const webrtc::PeerConnectionInterface::RTCConfiguration& config,
- rtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory,
- rtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory,
+ webrtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory,
+ webrtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory,
std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory,
std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory,
std::unique_ptr<webrtc::FieldTrialsView> field_trials = nullptr);
- rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory()
+ webrtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory()
const {
return peer_connection_factory_;
}
webrtc::PeerConnectionInterface* pc() { return peer_connection_.get(); }
- rtc::scoped_refptr<webrtc::DataChannelInterface> CreateDataChannel(
+ webrtc::scoped_refptr<webrtc::DataChannelInterface> CreateDataChannel(
const std::string& label,
const webrtc::DataChannelInit& init);
@@ -88,11 +88,11 @@
void OnSignalingChange(
webrtc::PeerConnectionInterface::SignalingState new_state) override;
void OnAddTrack(
- rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
- const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
+ webrtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
+ const std::vector<webrtc::scoped_refptr<webrtc::MediaStreamInterface>>&
streams) override;
- void OnDataChannel(
- rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) override;
+ void OnDataChannel(webrtc::scoped_refptr<webrtc::DataChannelInterface>
+ data_channel) override;
void OnRenegotiationNeeded() override {}
void OnIceConnectionChange(
webrtc::PeerConnectionInterface::IceConnectionState new_state) override {}
@@ -127,7 +127,7 @@
sigslot::signal1<const std::string&> SignalOnSdpReady;
sigslot::signal1<webrtc::DataChannelInterface*> SignalOnDataChannel;
- rtc::scoped_refptr<webrtc::MediaStreamInterface> GetUserMedia(
+ webrtc::scoped_refptr<webrtc::MediaStreamInterface> GetUserMedia(
bool audio,
const webrtc::AudioOptions& audio_options,
bool video,
@@ -148,14 +148,14 @@
webrtc::Thread* const network_thread_;
webrtc::Thread* const worker_thread_;
webrtc::SequenceChecker pc_thread_checker_;
- rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
- rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
+ webrtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
+ webrtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
peer_connection_factory_;
- rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
+ webrtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
std::unique_ptr<webrtc::FakeVideoTrackRenderer> renderer_;
int num_get_user_media_calls_ = 0;
bool pending_negotiation_;
- std::vector<rtc::scoped_refptr<webrtc::FakePeriodicVideoTrackSource>>
+ std::vector<webrtc::scoped_refptr<webrtc::FakePeriodicVideoTrackSource>>
fake_video_sources_;
};
diff --git a/pc/test/rtc_stats_obtainer.h b/pc/test/rtc_stats_obtainer.h
index e0d0786..2013539 100644
--- a/pc/test/rtc_stats_obtainer.h
+++ b/pc/test/rtc_stats_obtainer.h
@@ -22,33 +22,32 @@
class RTCStatsObtainer : public RTCStatsCollectorCallback {
public:
- static rtc::scoped_refptr<RTCStatsObtainer> Create(
- rtc::scoped_refptr<const RTCStatsReport>* report_ptr = nullptr) {
- return rtc::make_ref_counted<RTCStatsObtainer>(report_ptr);
+ static scoped_refptr<RTCStatsObtainer> Create(
+ scoped_refptr<const RTCStatsReport>* report_ptr = nullptr) {
+ return make_ref_counted<RTCStatsObtainer>(report_ptr);
}
void OnStatsDelivered(
- const rtc::scoped_refptr<const RTCStatsReport>& report) override {
+ const scoped_refptr<const RTCStatsReport>& report) override {
EXPECT_TRUE(thread_checker_.IsCurrent());
report_ = report;
if (report_ptr_)
*report_ptr_ = report_;
}
- rtc::scoped_refptr<const RTCStatsReport> report() const {
+ scoped_refptr<const RTCStatsReport> report() const {
EXPECT_TRUE(thread_checker_.IsCurrent());
return report_;
}
protected:
- explicit RTCStatsObtainer(
- rtc::scoped_refptr<const RTCStatsReport>* report_ptr)
+ explicit RTCStatsObtainer(scoped_refptr<const RTCStatsReport>* report_ptr)
: report_ptr_(report_ptr) {}
private:
SequenceChecker thread_checker_;
- rtc::scoped_refptr<const RTCStatsReport> report_;
- rtc::scoped_refptr<const RTCStatsReport>* report_ptr_;
+ scoped_refptr<const RTCStatsReport> report_;
+ scoped_refptr<const RTCStatsReport>* report_ptr_;
};
} // namespace webrtc
diff --git a/pc/test/rtp_transport_test_util.h b/pc/test/rtp_transport_test_util.h
index 69d4c97..82d2505 100644
--- a/pc/test/rtp_transport_test_util.h
+++ b/pc/test/rtp_transport_test_util.h
@@ -31,7 +31,7 @@
explicit TransportObserver(RtpTransportInternal* rtp_transport) {
rtp_transport->SubscribeRtcpPacketReceived(
- this, [this](rtc::CopyOnWriteBuffer* buffer, int64_t packet_time_ms) {
+ this, [this](CopyOnWriteBuffer* buffer, int64_t packet_time_ms) {
OnRtcpPacketReceived(buffer, packet_time_ms);
});
rtp_transport->SubscribeReadyToSend(
@@ -39,7 +39,7 @@
rtp_transport->SetUnDemuxableRtpPacketReceivedHandler(
[this](RtpPacketReceived& packet) { OnUndemuxableRtpPacket(packet); });
rtp_transport->SubscribeSentPacket(this,
- [this](const rtc::SentPacket& packet) {
+ [this](const SentPacketInfo& packet) {
sent_packet_count_++;
if (action_on_sent_packet_) {
action_on_sent_packet_();
@@ -57,8 +57,7 @@
un_demuxable_rtp_count_++;
}
- void OnRtcpPacketReceived(rtc::CopyOnWriteBuffer* packet,
- int64_t packet_time_us) {
+ void OnRtcpPacketReceived(CopyOnWriteBuffer* packet, int64_t packet_time_us) {
rtcp_count_++;
last_recv_rtcp_packet_ = *packet;
}
@@ -72,9 +71,7 @@
return last_recv_rtp_packet_;
}
- rtc::CopyOnWriteBuffer last_recv_rtcp_packet() {
- return last_recv_rtcp_packet_;
- }
+ CopyOnWriteBuffer last_recv_rtcp_packet() { return last_recv_rtcp_packet_; }
void OnReadyToSend(bool ready) {
if (action_on_ready_to_send_) {
@@ -103,7 +100,7 @@
int sent_packet_count_ = 0;
int ready_to_send_signal_count_ = 0;
RtpPacketReceived last_recv_rtp_packet_;
- rtc::CopyOnWriteBuffer last_recv_rtcp_packet_;
+ CopyOnWriteBuffer last_recv_rtcp_packet_;
absl::AnyInvocable<void(bool)> action_on_ready_to_send_;
absl::AnyInvocable<void()> action_on_sent_packet_;
};
diff --git a/pc/test/simulcast_layer_util.cc b/pc/test/simulcast_layer_util.cc
index 60fff5d..aebc713 100644
--- a/pc/test/simulcast_layer_util.cc
+++ b/pc/test/simulcast_layer_util.cc
@@ -43,7 +43,7 @@
RtpTransceiverInit CreateTransceiverInit(
const std::vector<SimulcastLayer>& layers) {
RtpTransceiverInit init;
- for (const cricket::SimulcastLayer& layer : layers) {
+ for (const SimulcastLayer& layer : layers) {
RtpEncodingParameters encoding;
encoding.rid = layer.rid;
encoding.active = !layer.is_paused;
diff --git a/pc/test/srtp_test_util.h b/pc/test/srtp_test_util.h
index ba0c355..3f8c6c1 100644
--- a/pc/test/srtp_test_util.h
+++ b/pc/test/srtp_test_util.h
@@ -19,9 +19,9 @@
namespace webrtc {
-static const rtc::ZeroOnFreeBuffer<uint8_t> kTestKey1{
+static const ZeroOnFreeBuffer<uint8_t> kTestKey1{
"ABCDEFGHIJKLMNOPQRSTUVWXYZ1234", 30};
-static const rtc::ZeroOnFreeBuffer<uint8_t> kTestKey2{
+static const ZeroOnFreeBuffer<uint8_t> kTestKey2{
"4321ZYXWVUTSRQPONMLKJIHGFEDCBA", 30};
static int rtp_auth_tag_len(int crypto_suite) {
diff --git a/pc/test/svc_e2e_tests.cc b/pc/test/svc_e2e_tests.cc
index 8193bd0..60469c7 100644
--- a/pc/test/svc_e2e_tests.cc
+++ b/pc/test/svc_e2e_tests.cc
@@ -213,7 +213,7 @@
void OnStatsReports(
absl::string_view pc_label,
- const rtc::scoped_refptr<const RTCStatsReport>& report) override {
+ const scoped_refptr<const RTCStatsReport>& report) override {
// Extract the scalability mode reported in the stats.
auto outbound_stats = report->GetStatsOfType<RTCOutboundRtpStreamStats>();
for (const auto& stat : outbound_stats) {
diff --git a/pc/track_media_info_map.cc b/pc/track_media_info_map.cc
index 6d849b9..a1eef98 100644
--- a/pc/track_media_info_map.cc
+++ b/pc/track_media_info_map.cc
@@ -45,8 +45,8 @@
}
void GetAudioAndVideoTrackBySsrc(
- rtc::ArrayView<rtc::scoped_refptr<RtpSenderInternal>> rtp_senders,
- rtc::ArrayView<rtc::scoped_refptr<RtpReceiverInternal>> rtp_receivers,
+ ArrayView<scoped_refptr<RtpSenderInternal>> rtp_senders,
+ ArrayView<scoped_refptr<RtpReceiverInternal>> rtp_receivers,
std::map<uint32_t, AudioTrackInterface*>* local_audio_track_by_ssrc,
std::map<uint32_t, VideoTrackInterface*>* local_video_track_by_ssrc,
std::map<uint32_t, AudioTrackInterface*>* remote_audio_track_by_ssrc,
@@ -116,8 +116,8 @@
void TrackMediaInfoMap::Initialize(
std::optional<VoiceMediaInfo> voice_media_info,
std::optional<VideoMediaInfo> video_media_info,
- rtc::ArrayView<rtc::scoped_refptr<RtpSenderInternal>> rtp_senders,
- rtc::ArrayView<rtc::scoped_refptr<RtpReceiverInternal>> rtp_receivers) {
+ ArrayView<scoped_refptr<RtpSenderInternal>> rtp_senders,
+ ArrayView<scoped_refptr<RtpReceiverInternal>> rtp_receivers) {
Thread::ScopedDisallowBlockingCalls no_blocking_calls;
RTC_DCHECK(!is_initialized_);
is_initialized_ = true;
@@ -245,25 +245,25 @@
return FindValueOrNull(video_info_by_receiver_ssrc_, ssrc);
}
-rtc::scoped_refptr<AudioTrackInterface> TrackMediaInfoMap::GetAudioTrack(
+scoped_refptr<AudioTrackInterface> TrackMediaInfoMap::GetAudioTrack(
const VoiceSenderInfo& voice_sender_info) const {
RTC_DCHECK(is_initialized_);
return FindValueOrNull(audio_track_by_sender_info_, &voice_sender_info);
}
-rtc::scoped_refptr<AudioTrackInterface> TrackMediaInfoMap::GetAudioTrack(
+scoped_refptr<AudioTrackInterface> TrackMediaInfoMap::GetAudioTrack(
const VoiceReceiverInfo& voice_receiver_info) const {
RTC_DCHECK(is_initialized_);
return FindValueOrNull(audio_track_by_receiver_info_, &voice_receiver_info);
}
-rtc::scoped_refptr<VideoTrackInterface> TrackMediaInfoMap::GetVideoTrack(
+scoped_refptr<VideoTrackInterface> TrackMediaInfoMap::GetVideoTrack(
const VideoSenderInfo& video_sender_info) const {
RTC_DCHECK(is_initialized_);
return FindValueOrNull(video_track_by_sender_info_, &video_sender_info);
}
-rtc::scoped_refptr<VideoTrackInterface> TrackMediaInfoMap::GetVideoTrack(
+scoped_refptr<VideoTrackInterface> TrackMediaInfoMap::GetVideoTrack(
const VideoReceiverInfo& video_receiver_info) const {
RTC_DCHECK(is_initialized_);
return FindValueOrNull(video_track_by_receiver_info_, &video_receiver_info);
diff --git a/pc/track_media_info_map.h b/pc/track_media_info_map.h
index ea19b00..eb20255 100644
--- a/pc/track_media_info_map.h
+++ b/pc/track_media_info_map.h
@@ -40,11 +40,10 @@
// Takes ownership of the "infos". Does not affect the lifetime of the senders
// or receivers, but TrackMediaInfoMap will keep their associated tracks alive
// through reference counting until the map is destroyed.
- void Initialize(
- std::optional<VoiceMediaInfo> voice_media_info,
- std::optional<VideoMediaInfo> video_media_info,
- rtc::ArrayView<rtc::scoped_refptr<RtpSenderInternal>> rtp_senders,
- rtc::ArrayView<rtc::scoped_refptr<RtpReceiverInternal>> rtp_receivers);
+ void Initialize(std::optional<VoiceMediaInfo> voice_media_info,
+ std::optional<VideoMediaInfo> video_media_info,
+ ArrayView<scoped_refptr<RtpSenderInternal>> rtp_senders,
+ ArrayView<scoped_refptr<RtpReceiverInternal>> rtp_receivers);
const std::optional<VoiceMediaInfo>& voice_media_info() const {
RTC_DCHECK(is_initialized_);
@@ -60,13 +59,13 @@
const VideoSenderInfo* GetVideoSenderInfoBySsrc(uint32_t ssrc) const;
const VideoReceiverInfo* GetVideoReceiverInfoBySsrc(uint32_t ssrc) const;
- rtc::scoped_refptr<AudioTrackInterface> GetAudioTrack(
+ scoped_refptr<AudioTrackInterface> GetAudioTrack(
const VoiceSenderInfo& voice_sender_info) const;
- rtc::scoped_refptr<AudioTrackInterface> GetAudioTrack(
+ scoped_refptr<AudioTrackInterface> GetAudioTrack(
const VoiceReceiverInfo& voice_receiver_info) const;
- rtc::scoped_refptr<VideoTrackInterface> GetVideoTrack(
+ scoped_refptr<VideoTrackInterface> GetVideoTrack(
const VideoSenderInfo& video_sender_info) const;
- rtc::scoped_refptr<VideoTrackInterface> GetVideoTrack(
+ scoped_refptr<VideoTrackInterface> GetVideoTrack(
const VideoReceiverInfo& video_receiver_info) const;
// TODO(hta): Remove this function, and redesign the callers not to need it.
@@ -84,13 +83,13 @@
// the inverse of the maps above. One info object always maps to only one
// track. The use of scoped_refptr<> here ensures the tracks outlive
// TrackMediaInfoMap.
- std::map<const VoiceSenderInfo*, rtc::scoped_refptr<AudioTrackInterface>>
+ std::map<const VoiceSenderInfo*, scoped_refptr<AudioTrackInterface>>
audio_track_by_sender_info_;
- std::map<const VoiceReceiverInfo*, rtc::scoped_refptr<AudioTrackInterface>>
+ std::map<const VoiceReceiverInfo*, scoped_refptr<AudioTrackInterface>>
audio_track_by_receiver_info_;
- std::map<const VideoSenderInfo*, rtc::scoped_refptr<VideoTrackInterface>>
+ std::map<const VideoSenderInfo*, scoped_refptr<VideoTrackInterface>>
video_track_by_sender_info_;
- std::map<const VideoReceiverInfo*, rtc::scoped_refptr<VideoTrackInterface>>
+ std::map<const VideoReceiverInfo*, scoped_refptr<VideoTrackInterface>>
video_track_by_receiver_info_;
// Map of tracks to attachment IDs.
// Necessary because senders and receivers live on the signaling thread,
diff --git a/pc/track_media_info_map_unittest.cc b/pc/track_media_info_map_unittest.cc
index 5fe7da0..a9487cc 100644
--- a/pc/track_media_info_map_unittest.cc
+++ b/pc/track_media_info_map_unittest.cc
@@ -54,17 +54,17 @@
return params;
}
-rtc::scoped_refptr<MockRtpSenderInternal> CreateMockRtpSender(
+scoped_refptr<MockRtpSenderInternal> CreateMockRtpSender(
webrtc::MediaType media_type,
std::initializer_list<uint32_t> ssrcs,
- rtc::scoped_refptr<MediaStreamTrackInterface> track) {
+ scoped_refptr<MediaStreamTrackInterface> track) {
uint32_t first_ssrc;
if (ssrcs.size()) {
first_ssrc = *ssrcs.begin();
} else {
first_ssrc = 0;
}
- auto sender = rtc::make_ref_counted<MockRtpSenderInternal>();
+ auto sender = make_ref_counted<MockRtpSenderInternal>();
EXPECT_CALL(*sender, track())
.WillRepeatedly(::testing::Return(std::move(track)));
EXPECT_CALL(*sender, ssrc()).WillRepeatedly(::testing::Return(first_ssrc));
@@ -76,11 +76,11 @@
return sender;
}
-rtc::scoped_refptr<MockRtpReceiverInternal> CreateMockRtpReceiver(
+scoped_refptr<MockRtpReceiverInternal> CreateMockRtpReceiver(
webrtc::MediaType media_type,
std::initializer_list<uint32_t> ssrcs,
- rtc::scoped_refptr<MediaStreamTrackInterface> track) {
- auto receiver = rtc::make_ref_counted<MockRtpReceiverInternal>();
+ scoped_refptr<MediaStreamTrackInterface> track) {
+ auto receiver = make_ref_counted<MockRtpReceiverInternal>();
EXPECT_CALL(*receiver, track())
.WillRepeatedly(::testing::Return(std::move(track)));
EXPECT_CALL(*receiver, media_type())
@@ -91,14 +91,12 @@
return receiver;
}
-rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack(
- const std::string& id) {
+scoped_refptr<VideoTrackInterface> CreateVideoTrack(const std::string& id) {
return VideoTrack::Create(id, FakeVideoTrackSource::Create(false),
Thread::Current());
}
-rtc::scoped_refptr<VideoTrackInterface> CreateMockVideoTrack(
- const std::string& id) {
+scoped_refptr<VideoTrackInterface> CreateMockVideoTrack(const std::string& id) {
auto track = MockVideoTrack::Create();
EXPECT_CALL(*track, kind())
.WillRepeatedly(::testing::Return(VideoTrack::kVideoKind));
@@ -121,11 +119,11 @@
void AddRtpSenderWithSsrcs(std::initializer_list<uint32_t> ssrcs,
MediaStreamTrackInterface* local_track) {
- rtc::scoped_refptr<MockRtpSenderInternal> rtp_sender = CreateMockRtpSender(
+ scoped_refptr<MockRtpSenderInternal> rtp_sender = CreateMockRtpSender(
local_track->kind() == MediaStreamTrackInterface::kAudioKind
? webrtc::MediaType::AUDIO
: webrtc::MediaType::VIDEO,
- ssrcs, rtc::scoped_refptr<MediaStreamTrackInterface>(local_track));
+ ssrcs, scoped_refptr<MediaStreamTrackInterface>(local_track));
rtp_senders_.push_back(rtp_sender);
if (local_track->kind() == MediaStreamTrackInterface::kAudioKind) {
@@ -154,7 +152,7 @@
remote_track->kind() == MediaStreamTrackInterface::kAudioKind
? webrtc::MediaType::AUDIO
: webrtc::MediaType::VIDEO,
- ssrcs, rtc::scoped_refptr<MediaStreamTrackInterface>(remote_track));
+ ssrcs, scoped_refptr<MediaStreamTrackInterface>(remote_track));
rtp_receivers_.push_back(rtp_receiver);
if (remote_track->kind() == MediaStreamTrackInterface::kAudioKind) {
@@ -189,13 +187,13 @@
VideoMediaInfo video_media_info_;
protected:
- std::vector<rtc::scoped_refptr<RtpSenderInternal>> rtp_senders_;
- std::vector<rtc::scoped_refptr<RtpReceiverInternal>> rtp_receivers_;
+ std::vector<scoped_refptr<RtpSenderInternal>> rtp_senders_;
+ std::vector<scoped_refptr<RtpReceiverInternal>> rtp_receivers_;
TrackMediaInfoMap map_;
- rtc::scoped_refptr<AudioTrack> local_audio_track_;
- rtc::scoped_refptr<AudioTrack> remote_audio_track_;
- rtc::scoped_refptr<VideoTrackInterface> local_video_track_;
- rtc::scoped_refptr<VideoTrackInterface> remote_video_track_;
+ scoped_refptr<AudioTrack> local_audio_track_;
+ scoped_refptr<AudioTrack> remote_audio_track_;
+ scoped_refptr<VideoTrackInterface> local_video_track_;
+ scoped_refptr<VideoTrackInterface> remote_video_track_;
};
} // namespace
diff --git a/pc/transceiver_list.cc b/pc/transceiver_list.cc
index 60474f0..4e7df5e 100644
--- a/pc/transceiver_list.cc
+++ b/pc/transceiver_list.cc
@@ -61,7 +61,7 @@
}
RtpTransceiverProxyRefPtr TransceiverList::FindBySender(
- rtc::scoped_refptr<RtpSenderInterface> sender) const {
+ scoped_refptr<RtpSenderInterface> sender) const {
RTC_DCHECK_RUN_ON(&sequence_checker_);
for (auto transceiver : transceivers_) {
if (transceiver->sender() == sender) {
diff --git a/pc/transceiver_list.h b/pc/transceiver_list.h
index 9e03171..1abb7d2 100644
--- a/pc/transceiver_list.h
+++ b/pc/transceiver_list.h
@@ -32,7 +32,7 @@
namespace webrtc {
-typedef rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+typedef scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
RtpTransceiverProxyRefPtr;
// Captures partial state to be used for rollback. Applicable only in
@@ -94,7 +94,7 @@
class TransceiverList {
public:
// Returns a copy of the currently active list of transceivers. The
- // list consists of rtc::scoped_refptrs, which will keep the transceivers
+ // list consists of webrtc::scoped_refptrs, which will keep the transceivers
// from being deallocated, even if they are removed from the TransceiverList.
std::vector<RtpTransceiverProxyRefPtr> List() const {
RTC_DCHECK_RUN_ON(&sequence_checker_);
@@ -122,7 +122,7 @@
transceivers_.end());
}
RtpTransceiverProxyRefPtr FindBySender(
- rtc::scoped_refptr<RtpSenderInterface> sender) const;
+ scoped_refptr<RtpSenderInterface> sender) const;
RtpTransceiverProxyRefPtr FindByMid(const std::string& mid) const;
RtpTransceiverProxyRefPtr FindByMLineIndex(size_t mline_index) const;
diff --git a/pc/video_rtp_receiver.cc b/pc/video_rtp_receiver.cc
index c6acc60..0e18ade 100644
--- a/pc/video_rtp_receiver.cc
+++ b/pc/video_rtp_receiver.cc
@@ -51,10 +51,10 @@
VideoRtpReceiver::VideoRtpReceiver(
Thread* worker_thread,
const std::string& receiver_id,
- const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams)
+ const std::vector<scoped_refptr<MediaStreamInterface>>& streams)
: worker_thread_(worker_thread),
id_(receiver_id),
- source_(rtc::make_ref_counted<VideoRtpTrackSource>(&source_callback_)),
+ source_(make_ref_counted<VideoRtpTrackSource>(&source_callback_)),
track_(VideoTrackProxyWithInternal<VideoTrack>::Create(
Thread::Current(),
worker_thread,
@@ -78,14 +78,13 @@
return stream_ids;
}
-rtc::scoped_refptr<DtlsTransportInterface> VideoRtpReceiver::dtls_transport()
- const {
+scoped_refptr<DtlsTransportInterface> VideoRtpReceiver::dtls_transport() const {
RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
return dtls_transport_;
}
-std::vector<rtc::scoped_refptr<MediaStreamInterface>>
-VideoRtpReceiver::streams() const {
+std::vector<scoped_refptr<MediaStreamInterface>> VideoRtpReceiver::streams()
+ const {
RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
return streams_;
}
@@ -101,7 +100,7 @@
}
void VideoRtpReceiver::SetFrameDecryptor(
- rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
+ scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
RTC_DCHECK_RUN_ON(worker_thread_);
frame_decryptor_ = std::move(frame_decryptor);
// Special Case: Set the frame decryptor to any value on any existing channel.
@@ -110,14 +109,14 @@
}
}
-rtc::scoped_refptr<FrameDecryptorInterface>
-VideoRtpReceiver::GetFrameDecryptor() const {
+scoped_refptr<FrameDecryptorInterface> VideoRtpReceiver::GetFrameDecryptor()
+ const {
RTC_DCHECK_RUN_ON(worker_thread_);
return frame_decryptor_;
}
void VideoRtpReceiver::SetFrameTransformer(
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) {
+ scoped_refptr<FrameTransformerInterface> frame_transformer) {
RTC_DCHECK_RUN_ON(worker_thread_);
frame_transformer_ = std::move(frame_transformer);
if (media_channel_) {
@@ -219,13 +218,13 @@
}
void VideoRtpReceiver::set_transport(
- rtc::scoped_refptr<DtlsTransportInterface> dtls_transport) {
+ scoped_refptr<DtlsTransportInterface> dtls_transport) {
RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
dtls_transport_ = std::move(dtls_transport);
}
void VideoRtpReceiver::SetStreams(
- const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
+ const std::vector<scoped_refptr<MediaStreamInterface>>& streams) {
RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
// Remove remote track from any streams that are going away.
for (const auto& existing_stream : streams_) {
diff --git a/pc/video_rtp_receiver.h b/pc/video_rtp_receiver.h
index 1a13116..5bd2e6a 100644
--- a/pc/video_rtp_receiver.h
+++ b/pc/video_rtp_receiver.h
@@ -54,20 +54,19 @@
VideoRtpReceiver(
Thread* worker_thread,
const std::string& receiver_id,
- const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams);
+ const std::vector<scoped_refptr<MediaStreamInterface>>& streams);
virtual ~VideoRtpReceiver();
- rtc::scoped_refptr<VideoTrackInterface> video_track() const { return track_; }
+ scoped_refptr<VideoTrackInterface> video_track() const { return track_; }
// RtpReceiverInterface implementation
- rtc::scoped_refptr<MediaStreamTrackInterface> track() const override {
+ scoped_refptr<MediaStreamTrackInterface> track() const override {
return track_;
}
- rtc::scoped_refptr<DtlsTransportInterface> dtls_transport() const override;
+ scoped_refptr<DtlsTransportInterface> dtls_transport() const override;
std::vector<std::string> stream_ids() const override;
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams()
- const override;
+ std::vector<scoped_refptr<MediaStreamInterface>> streams() const override;
webrtc::MediaType media_type() const override {
return webrtc::MediaType::VIDEO;
}
@@ -77,13 +76,12 @@
RtpParameters GetParameters() const override;
void SetFrameDecryptor(
- rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) override;
+ scoped_refptr<FrameDecryptorInterface> frame_decryptor) override;
- rtc::scoped_refptr<FrameDecryptorInterface> GetFrameDecryptor()
- const override;
+ scoped_refptr<FrameDecryptorInterface> GetFrameDecryptor() const override;
void SetFrameTransformer(
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) override;
+ scoped_refptr<FrameTransformerInterface> frame_transformer) override;
// RtpReceiverInternal implementation.
void Stop() override;
@@ -93,9 +91,9 @@
void NotifyFirstPacketReceived() override;
void set_stream_ids(std::vector<std::string> stream_ids) override;
void set_transport(
- rtc::scoped_refptr<DtlsTransportInterface> dtls_transport) override;
- void SetStreams(const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&
- streams) override;
+ scoped_refptr<DtlsTransportInterface> dtls_transport) override;
+ void SetStreams(
+ const std::vector<scoped_refptr<MediaStreamInterface>>& streams) override;
void SetObserver(RtpReceiverObserverInterface* observer) override;
@@ -152,20 +150,20 @@
std::optional<uint32_t> signaled_ssrc_ RTC_GUARDED_BY(worker_thread_);
// `source_` is held here to be able to change the state of the source when
// the VideoRtpReceiver is stopped.
- const rtc::scoped_refptr<VideoRtpTrackSource> source_;
- const rtc::scoped_refptr<VideoTrackProxyWithInternal<VideoTrack>> track_;
- std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams_
+ const scoped_refptr<VideoRtpTrackSource> source_;
+ const scoped_refptr<VideoTrackProxyWithInternal<VideoTrack>> track_;
+ std::vector<scoped_refptr<MediaStreamInterface>> streams_
RTC_GUARDED_BY(&signaling_thread_checker_);
RtpReceiverObserverInterface* observer_
RTC_GUARDED_BY(&signaling_thread_checker_) = nullptr;
bool received_first_packet_ RTC_GUARDED_BY(&signaling_thread_checker_) =
false;
const int attachment_id_;
- rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor_
+ scoped_refptr<FrameDecryptorInterface> frame_decryptor_
RTC_GUARDED_BY(worker_thread_);
- rtc::scoped_refptr<DtlsTransportInterface> dtls_transport_
+ scoped_refptr<DtlsTransportInterface> dtls_transport_
RTC_GUARDED_BY(&signaling_thread_checker_);
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer_
+ scoped_refptr<FrameTransformerInterface> frame_transformer_
RTC_GUARDED_BY(worker_thread_);
// Stores the minimum jitter buffer delay. Handles caching cases
// if `SetJitterBufferMinimumDelay` is called before start.
diff --git a/pc/video_rtp_receiver_unittest.cc b/pc/video_rtp_receiver_unittest.cc
index 5db0acd..b5131ad 100644
--- a/pc/video_rtp_receiver_unittest.cc
+++ b/pc/video_rtp_receiver_unittest.cc
@@ -79,7 +79,7 @@
VideoRtpReceiverTest()
: worker_thread_(Thread::Create()),
channel_(VideoOptions()),
- receiver_(rtc::make_ref_counted<VideoRtpReceiver>(
+ receiver_(make_ref_counted<VideoRtpReceiver>(
worker_thread_.get(),
std::string("receiver"),
std::vector<std::string>({"stream"}))) {
@@ -107,7 +107,7 @@
AutoThread main_thread_;
std::unique_ptr<Thread> worker_thread_;
NiceMock<MockVideoMediaReceiveChannel> channel_;
- rtc::scoped_refptr<VideoRtpReceiver> receiver_;
+ scoped_refptr<VideoRtpReceiver> receiver_;
};
TEST_F(VideoRtpReceiverTest, SupportsEncodedOutput) {
diff --git a/pc/video_rtp_track_source.cc b/pc/video_rtp_track_source.cc
index 5979836..7537de9 100644
--- a/pc/video_rtp_track_source.cc
+++ b/pc/video_rtp_track_source.cc
@@ -43,7 +43,7 @@
void VideoRtpTrackSource::BroadcastRecordableEncodedFrame(
const RecordableEncodedFrame& frame) const {
MutexLock lock(&mu_);
- for (rtc::VideoSinkInterface<RecordableEncodedFrame>* sink : encoded_sinks_) {
+ for (VideoSinkInterface<RecordableEncodedFrame>* sink : encoded_sinks_) {
sink->OnFrame(frame);
}
}
diff --git a/pc/video_rtp_track_source_unittest.cc b/pc/video_rtp_track_source_unittest.cc
index f95376c..4aefb17 100644
--- a/pc/video_rtp_track_source_unittest.cc
+++ b/pc/video_rtp_track_source_unittest.cc
@@ -37,9 +37,9 @@
MOCK_METHOD(void, OnFrame, (const RecordableEncodedFrame&), (override));
};
-rtc::scoped_refptr<VideoRtpTrackSource> MakeSource(
+scoped_refptr<VideoRtpTrackSource> MakeSource(
VideoRtpTrackSource::Callback* callback) {
- return rtc::make_ref_counted<VideoRtpTrackSource>(callback);
+ return make_ref_counted<VideoRtpTrackSource>(callback);
}
TEST(VideoRtpTrackSourceTest, CreatesWithRemoteAtttributeSet) {
@@ -113,7 +113,7 @@
class TestFrame : public RecordableEncodedFrame {
public:
- rtc::scoped_refptr<const EncodedImageBufferInterface> encoded_buffer()
+ scoped_refptr<const EncodedImageBufferInterface> encoded_buffer()
const override {
return nullptr;
}
diff --git a/pc/video_track.cc b/pc/video_track.cc
index 94bb5e7..ad2ce05 100644
--- a/pc/video_track.cc
+++ b/pc/video_track.cc
@@ -31,8 +31,8 @@
VideoTrack::VideoTrack(
absl::string_view label,
- rtc::scoped_refptr<
- VideoTrackSourceProxyWithInternal<VideoTrackSourceInterface>> source,
+ scoped_refptr<VideoTrackSourceProxyWithInternal<VideoTrackSourceInterface>>
+ source,
Thread* worker_thread)
: MediaStreamTrack<VideoTrackInterface>(label),
worker_thread_(worker_thread),
@@ -57,7 +57,7 @@
// AddOrUpdateSink and RemoveSink should be called on the worker
// thread.
-void VideoTrack::AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
+void VideoTrack::AddOrUpdateSink(VideoSinkInterface<VideoFrame>* sink,
const VideoSinkWants& wants) {
RTC_DCHECK_RUN_ON(worker_thread_);
VideoSourceBaseGuarded::AddOrUpdateSink(sink, wants);
@@ -66,7 +66,7 @@
video_source_->internal()->AddOrUpdateSink(sink, modified_wants);
}
-void VideoTrack::RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
+void VideoTrack::RemoveSink(VideoSinkInterface<VideoFrame>* sink) {
RTC_DCHECK_RUN_ON(worker_thread_);
VideoSourceBaseGuarded::RemoveSink(sink);
video_source_->internal()->RemoveSink(sink);
@@ -138,17 +138,16 @@
set_state(state == MediaSourceInterface::kEnded ? kEnded : kLive);
}
-rtc::scoped_refptr<VideoTrack> VideoTrack::Create(
+scoped_refptr<VideoTrack> VideoTrack::Create(
absl::string_view id,
- rtc::scoped_refptr<VideoTrackSourceInterface> source,
+ scoped_refptr<VideoTrackSourceInterface> source,
Thread* worker_thread) {
- rtc::scoped_refptr<
- VideoTrackSourceProxyWithInternal<VideoTrackSourceInterface>>
+ scoped_refptr<VideoTrackSourceProxyWithInternal<VideoTrackSourceInterface>>
source_proxy = VideoTrackSourceProxy::Create(
Thread::Current(), worker_thread, std::move(source));
- return rtc::make_ref_counted<VideoTrack>(id, std::move(source_proxy),
- worker_thread);
+ return make_ref_counted<VideoTrack>(id, std::move(source_proxy),
+ worker_thread);
}
} // namespace webrtc
diff --git a/pc/video_track.h b/pc/video_track.h
index 75eec0b..4c41550 100644
--- a/pc/video_track.h
+++ b/pc/video_track.h
@@ -37,9 +37,9 @@
public VideoSourceBaseGuarded,
public ObserverInterface {
public:
- static rtc::scoped_refptr<VideoTrack> Create(
+ static scoped_refptr<VideoTrack> Create(
absl::string_view label,
- rtc::scoped_refptr<VideoTrackSourceInterface> source,
+ scoped_refptr<VideoTrackSourceInterface> source,
Thread* worker_thread);
void AddOrUpdateSink(VideoSinkInterface<VideoFrame>* sink,
@@ -61,7 +61,7 @@
protected:
VideoTrack(
absl::string_view id,
- rtc::scoped_refptr<
+ scoped_refptr<
VideoTrackSourceProxyWithInternal<VideoTrackSourceInterface>> source,
Thread* worker_thread);
~VideoTrack();
@@ -72,7 +72,7 @@
RTC_NO_UNIQUE_ADDRESS SequenceChecker signaling_thread_;
Thread* const worker_thread_;
- const rtc::scoped_refptr<
+ const scoped_refptr<
VideoTrackSourceProxyWithInternal<VideoTrackSourceInterface>>
video_source_;
ContentHint content_hint_ RTC_GUARDED_BY(&signaling_thread_);
diff --git a/pc/video_track_source.cc b/pc/video_track_source.cc
index d7d26c0..d9b5f19 100644
--- a/pc/video_track_source.cc
+++ b/pc/video_track_source.cc
@@ -30,14 +30,13 @@
}
}
-void VideoTrackSource::AddOrUpdateSink(
- rtc::VideoSinkInterface<VideoFrame>* sink,
- const VideoSinkWants& wants) {
+void VideoTrackSource::AddOrUpdateSink(VideoSinkInterface<VideoFrame>* sink,
+ const VideoSinkWants& wants) {
RTC_DCHECK(worker_thread_checker_.IsCurrent());
source()->AddOrUpdateSink(sink, wants);
}
-void VideoTrackSource::RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
+void VideoTrackSource::RemoveSink(VideoSinkInterface<VideoFrame>* sink) {
RTC_DCHECK(worker_thread_checker_.IsCurrent());
source()->RemoveSink(sink);
}
diff --git a/pc/video_track_source_proxy.cc b/pc/video_track_source_proxy.cc
index 95edcfe..d772f59 100644
--- a/pc/video_track_source_proxy.cc
+++ b/pc/video_track_source_proxy.cc
@@ -17,13 +17,13 @@
namespace webrtc {
-rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoTrackSourceProxy(
+scoped_refptr<VideoTrackSourceInterface> CreateVideoTrackSourceProxy(
Thread* signaling_thread,
Thread* worker_thread,
VideoTrackSourceInterface* source) {
return VideoTrackSourceProxy::Create(
signaling_thread, worker_thread,
- rtc::scoped_refptr<VideoTrackSourceInterface>(source));
+ scoped_refptr<VideoTrackSourceInterface>(source));
}
} // namespace webrtc
diff --git a/pc/video_track_unittest.cc b/pc/video_track_unittest.cc
index 7a93fb3..c003a51 100644
--- a/pc/video_track_unittest.cc
+++ b/pc/video_track_unittest.cc
@@ -35,7 +35,7 @@
public:
VideoTrackTest() : frame_source_(640, 480, webrtc::kNumMicrosecsPerSec / 30) {
static const char kVideoTrackId[] = "track_id";
- video_track_source_ = rtc::make_ref_counted<FakeVideoTrackSource>(
+ video_track_source_ = webrtc::make_ref_counted<FakeVideoTrackSource>(
/*is_screencast=*/false);
video_track_ = VideoTrack::Create(kVideoTrackId, video_track_source_,
webrtc::Thread::Current());
@@ -43,8 +43,8 @@
protected:
webrtc::AutoThread main_thread_;
- rtc::scoped_refptr<FakeVideoTrackSource> video_track_source_;
- rtc::scoped_refptr<VideoTrack> video_track_;
+ webrtc::scoped_refptr<FakeVideoTrackSource> video_track_source_;
+ webrtc::scoped_refptr<VideoTrack> video_track_;
webrtc::FakeFrameSource frame_source_;
};
diff --git a/pc/webrtc_sdp.cc b/pc/webrtc_sdp.cc
index 4b0240b..a87a82c 100644
--- a/pc/webrtc_sdp.cc
+++ b/pc/webrtc_sdp.cc
@@ -68,8 +68,8 @@
#include "rtc_base/string_encode.h"
#include "rtc_base/strings/string_builder.h"
-using cricket::Candidate;
using ::webrtc::AudioContentDescription;
+using webrtc::Candidate;
using ::webrtc::Candidates;
using ::webrtc::ContentInfo;
using ::webrtc::ICE_CANDIDATE_COMPONENT_RTCP;
@@ -203,9 +203,10 @@
static const char kCandidateRelay[] = "relay";
static const char kTcpCandidateType[] = "tcptype";
-// rtc::StringBuilder doesn't have a << overload for chars, while rtc::split and
-// rtc::tokenize_first both take a char delimiter. To handle both cases these
-// constants come in pairs of a chars and length-one strings.
+// webrtc::StringBuilder doesn't have a << overload for chars, while
+// webrtc::split and webrtc::tokenize_first both take a char delimiter. To
+// handle both cases these constants come in pairs of a chars and length-one
+// strings.
static const char kSdpDelimiterEqual[] = "=";
static const char kSdpDelimiterEqualChar = '=';
static const char kSdpDelimiterSpace[] = " ";
@@ -653,7 +654,7 @@
absl::string_view s,
T* t,
SdpParseError* error) {
- if (!rtc::FromString(s, t)) {
+ if (!FromString(s, t)) {
StringBuilder description;
description << "Invalid value: " << s << ".";
return ParseFailed(line, description.Release(), error);
@@ -873,7 +874,7 @@
// BUNDLE Groups
std::vector<const ContentGroup*> groups =
desc->GetGroupsByName(GROUP_TYPE_BUNDLE);
- for (const cricket::ContentGroup* group : groups) {
+ for (const ContentGroup* group : groups) {
std::string group_line = kAttrGroup;
RTC_DCHECK(group != NULL);
for (const std::string& content_name : group->content_names()) {
@@ -890,7 +891,7 @@
}
// MediaStream semantics.
- // TODO(bugs.webrtc.org/10421): Change to & cricket::kMsidSignalingSemantic
+ // TODO(bugs.webrtc.org/10421): Change to & webrtc::kMsidSignalingSemantic
// when we think it's safe to do so, so that we gradually fade out this old
// line that was removed from the specification.
if (desc->msid_signaling() != kMsidSignalingNotUsed) {
@@ -920,7 +921,7 @@
// TODO(deadbeef): It's weird that we need to iterate TransportInfos for
// this, when it's a session-level attribute. It really should be moved to a
// session-level structure like SessionDescription.
- for (const cricket::TransportInfo& transport : desc->transport_infos()) {
+ for (const TransportInfo& transport : desc->transport_infos()) {
if (transport.description.ice_mode == ICEMODE_LITE) {
InitAttrLine(kAttributeIceLite, &os);
AddLine(os.str(), &message);
@@ -2629,9 +2630,8 @@
bool HasDuplicateMsidLines(SessionDescription* desc) {
std::set<std::pair<std::string, std::string>> seen_msids;
- for (const cricket::ContentInfo& content : desc->contents()) {
- for (const cricket::StreamParams& stream :
- content.media_description()->streams()) {
+ for (const ContentInfo& content : desc->contents()) {
+ for (const StreamParams& stream : content.media_description()->streams()) {
auto msid = std::pair(stream.first_stream_id(), stream.id);
if (seen_msids.find(msid) != seen_msids.end()) {
return true;
diff --git a/pc/webrtc_sdp_unittest.cc b/pc/webrtc_sdp_unittest.cc
index 103ef8d..ba696d4 100644
--- a/pc/webrtc_sdp_unittest.cc
+++ b/pc/webrtc_sdp_unittest.cc
@@ -56,11 +56,11 @@
#endif
#include "pc/webrtc_sdp.h"
-using cricket::Candidate;
using ::testing::ElementsAre;
using ::testing::Field;
using ::testing::Property;
using ::webrtc::AudioContentDescription;
+using webrtc::Candidate;
using ::webrtc::ContentGroup;
using ::webrtc::ContentInfo;
using ::webrtc::ICE_CANDIDATE_COMPONENT_RTCP;
@@ -1452,8 +1452,8 @@
}
// group
- const cricket::ContentGroups groups1 = desc1.groups();
- const cricket::ContentGroups groups2 = desc2.groups();
+ const webrtc::ContentGroups groups1 = desc1.groups();
+ const webrtc::ContentGroups groups2 = desc2.groups();
EXPECT_EQ(groups1.size(), groups1.size());
if (groups1.size() != groups2.size()) {
ADD_FAILURE();
@@ -1463,23 +1463,23 @@
const webrtc::ContentGroup group1 = groups1.at(i);
const webrtc::ContentGroup group2 = groups2.at(i);
EXPECT_EQ(group1.semantics(), group2.semantics());
- const cricket::ContentNames names1 = group1.content_names();
- const cricket::ContentNames names2 = group2.content_names();
+ const webrtc::ContentNames names1 = group1.content_names();
+ const webrtc::ContentNames names2 = group2.content_names();
EXPECT_EQ(names1.size(), names2.size());
if (names1.size() != names2.size()) {
ADD_FAILURE();
return;
}
- cricket::ContentNames::const_iterator iter1 = names1.begin();
- cricket::ContentNames::const_iterator iter2 = names2.begin();
+ webrtc::ContentNames::const_iterator iter1 = names1.begin();
+ webrtc::ContentNames::const_iterator iter2 = names2.begin();
while (iter1 != names1.end()) {
EXPECT_EQ(*iter1++, *iter2++);
}
}
// transport info
- const cricket::TransportInfos transports1 = desc1.transport_infos();
- const cricket::TransportInfos transports2 = desc2.transport_infos();
+ const webrtc::TransportInfos transports1 = desc1.transport_infos();
+ const webrtc::TransportInfos transports2 = desc2.transport_infos();
EXPECT_EQ(transports1.size(), transports2.size());
if (transports1.size() != transports2.size()) {
ADD_FAILURE();
@@ -1620,8 +1620,7 @@
// Removes everything in StreamParams from the session description that is
// used for a=ssrc lines.
void RemoveSsrcSignalingFromStreamParams() {
- for (cricket::ContentInfo& content_info :
- jdesc_.description()->contents()) {
+ for (webrtc::ContentInfo& content_info : jdesc_.description()->contents()) {
// With Unified Plan there should be one StreamParams per m= section.
StreamParams& stream =
content_info.media_description()->mutable_streams()[0];
@@ -2659,7 +2658,7 @@
sdp = kSdpTcpActiveCandidate;
EXPECT_TRUE(SdpDeserializeCandidate(sdp, &jcandidate));
- // Make a cricket::Candidate equivalent to kSdpTcpCandidate string.
+ // Make a webrtc::Candidate equivalent to kSdpTcpCandidate string.
Candidate candidate(webrtc::ICE_CANDIDATE_COMPONENT_RTP, "tcp",
webrtc::SocketAddress("192.168.1.5", 9),
kCandidatePriority, "", "", IceCandidateType::kHost,
@@ -4472,7 +4471,7 @@
JsepSessionDescription output(kDummyType);
SdpParseError error;
EXPECT_TRUE(webrtc::SdpDeserialize(sdp, &output, &error));
- const cricket::ContentInfos& contents = output.description()->contents();
+ const webrtc::ContentInfos& contents = output.description()->contents();
const webrtc::MediaContentDescription* media =
contents.back().media_description();
EXPECT_TRUE(media->HasSimulcast());
@@ -4493,7 +4492,7 @@
JsepSessionDescription output(kDummyType);
SdpParseError error;
EXPECT_TRUE(webrtc::SdpDeserialize(sdp, &output, &error));
- const cricket::ContentInfos& contents = output.description()->contents();
+ const webrtc::ContentInfos& contents = output.description()->contents();
const webrtc::MediaContentDescription* media =
contents.back().media_description();
EXPECT_TRUE(media->HasSimulcast());
@@ -4531,7 +4530,7 @@
JsepSessionDescription output(kDummyType);
SdpParseError error;
EXPECT_TRUE(webrtc::SdpDeserialize(sdp, &output, &error));
- const cricket::ContentInfos& contents = output.description()->contents();
+ const webrtc::ContentInfos& contents = output.description()->contents();
const webrtc::MediaContentDescription* media =
contents.back().media_description();
EXPECT_TRUE(media->HasSimulcast());
@@ -4557,7 +4556,7 @@
JsepSessionDescription output(kDummyType);
SdpParseError error;
EXPECT_TRUE(webrtc::SdpDeserialize(sdp, &output, &error));
- const cricket::ContentInfos& contents = output.description()->contents();
+ const webrtc::ContentInfos& contents = output.description()->contents();
const webrtc::MediaContentDescription* media =
contents.back().media_description();
EXPECT_TRUE(media->HasSimulcast());
@@ -4583,7 +4582,7 @@
JsepSessionDescription output(kDummyType);
SdpParseError error;
EXPECT_TRUE(webrtc::SdpDeserialize(sdp, &output, &error));
- const cricket::ContentInfos& contents = output.description()->contents();
+ const webrtc::ContentInfos& contents = output.description()->contents();
const webrtc::MediaContentDescription* media =
contents.back().media_description();
EXPECT_TRUE(media->HasSimulcast());
@@ -4606,7 +4605,7 @@
JsepSessionDescription output(kDummyType);
SdpParseError error;
EXPECT_TRUE(webrtc::SdpDeserialize(sdp, &output, &error));
- const cricket::ContentInfos& contents = output.description()->contents();
+ const webrtc::ContentInfos& contents = output.description()->contents();
const webrtc::MediaContentDescription* media =
contents.back().media_description();
EXPECT_TRUE(media->HasSimulcast());
@@ -4637,7 +4636,7 @@
JsepSessionDescription output(kDummyType);
SdpParseError error;
EXPECT_TRUE(webrtc::SdpDeserialize(sdp, &output, &error));
- const cricket::ContentInfos& contents = output.description()->contents();
+ const webrtc::ContentInfos& contents = output.description()->contents();
const webrtc::MediaContentDescription* media =
contents.back().media_description();
EXPECT_TRUE(media->HasSimulcast());
@@ -4660,7 +4659,7 @@
JsepSessionDescription output(kDummyType);
SdpParseError error;
EXPECT_TRUE(webrtc::SdpDeserialize(sdp, &output, &error));
- const cricket::ContentInfos& contents = output.description()->contents();
+ const webrtc::ContentInfos& contents = output.description()->contents();
const webrtc::MediaContentDescription* media =
contents.back().media_description();
EXPECT_FALSE(media->HasSimulcast());
@@ -4674,7 +4673,7 @@
JsepSessionDescription output(kDummyType);
SdpParseError error;
EXPECT_TRUE(webrtc::SdpDeserialize(sdp, &output, &error));
- const cricket::ContentInfos& contents = output.description()->contents();
+ const webrtc::ContentInfos& contents = output.description()->contents();
const webrtc::MediaContentDescription* media =
contents.back().media_description();
EXPECT_FALSE(media->HasSimulcast());
@@ -4692,7 +4691,7 @@
JsepSessionDescription output(kDummyType);
SdpParseError error;
EXPECT_TRUE(webrtc::SdpDeserialize(sdp, &output, &error));
- const cricket::ContentInfos& contents = output.description()->contents();
+ const webrtc::ContentInfos& contents = output.description()->contents();
const webrtc::MediaContentDescription* media =
contents.back().media_description();
EXPECT_TRUE(media->HasSimulcast());
diff --git a/pc/webrtc_session_description_factory.cc b/pc/webrtc_session_description_factory.cc
index eccfcbf..0ca42e4 100644
--- a/pc/webrtc_session_description_factory.cc
+++ b/pc/webrtc_session_description_factory.cc
@@ -45,8 +45,8 @@
#include "rtc_base/ssl_stream_adapter.h"
#include "rtc_base/unique_id_generator.h"
-using rtc::UniqueRandomIdGenerator;
using ::webrtc::MediaSessionOptions;
+using webrtc::UniqueRandomIdGenerator;
namespace webrtc {
namespace {
@@ -61,7 +61,7 @@
static bool ValidMediaSessionOptions(
const MediaSessionOptions& session_options) {
std::vector<SenderOptions> sorted_senders;
- for (const cricket::MediaDescriptionOptions& media_description_options :
+ for (const MediaDescriptionOptions& media_description_options :
session_options.media_description_options) {
sorted_senders.insert(sorted_senders.end(),
media_description_options.sender_options.begin(),
@@ -87,8 +87,7 @@
if (!source_desc) {
return;
}
- const cricket::ContentInfos& contents =
- source_desc->description()->contents();
+ const ContentInfos& contents = source_desc->description()->contents();
const ContentInfo* cinfo =
source_desc->description()->GetContentByName(content_name);
if (!cinfo) {
@@ -116,8 +115,8 @@
const std::string& session_id,
bool dtls_enabled,
std::unique_ptr<RTCCertificateGeneratorInterface> cert_generator,
- rtc::scoped_refptr<RTCCertificate> certificate,
- std::function<void(const rtc::scoped_refptr<webrtc::RTCCertificate>&)>
+ scoped_refptr<RTCCertificate> certificate,
+ std::function<void(const webrtc::scoped_refptr<webrtc::RTCCertificate>&)>
on_certificate_ready,
CodecLookupHelper* codec_lookup_helper,
const FieldTrialsView& field_trials)
@@ -159,7 +158,7 @@
certificate_request_state_ = CERTIFICATE_WAITING;
auto callback = [weak_ptr = weak_factory_.GetWeakPtr()](
- rtc::scoped_refptr<rtc::RTCCertificate> certificate) {
+ scoped_refptr<RTCCertificate> certificate) {
if (!weak_ptr) {
return;
}
@@ -274,7 +273,7 @@
if (sdp_info_->local_description()) {
// If the needs-ice-restart flag is set as described by JSEP, we should
// generate an offer with a new ufrag/password to trigger an ICE restart.
- for (cricket::MediaDescriptionOptions& options :
+ for (MediaDescriptionOptions& options :
request.options.media_description_options) {
if (sdp_info_->NeedsIceRestart(options.mid)) {
options.transport_options.ice_restart = true;
@@ -307,7 +306,7 @@
SdpType::kOffer, std::move(desc), session_id_,
absl::StrCat(session_version_++));
if (sdp_info_->local_description()) {
- for (const cricket::MediaDescriptionOptions& options :
+ for (const MediaDescriptionOptions& options :
request.options.media_description_options) {
if (!options.transport_options.ice_restart) {
CopyCandidatesFromSessionDescription(sdp_info_->local_description(),
@@ -322,7 +321,7 @@
void WebRtcSessionDescriptionFactory::InternalCreateAnswer(
CreateSessionDescriptionRequest request) {
if (sdp_info_->remote_description()) {
- for (cricket::MediaDescriptionOptions& options :
+ for (MediaDescriptionOptions& options :
request.options.media_description_options) {
// According to http://tools.ietf.org/html/rfc5245#section-9.2.1.1
// an answer should also contain new ICE ufrag and password if an offer
@@ -331,11 +330,10 @@
sdp_info_->IceRestartPending(options.mid);
// We should pass the current DTLS role to the transport description
// factory, if there is already an existing ongoing session.
- std::optional<rtc::SSLRole> dtls_role =
- sdp_info_->GetDtlsRole(options.mid);
+ std::optional<SSLRole> dtls_role = sdp_info_->GetDtlsRole(options.mid);
if (dtls_role) {
options.transport_options.prefer_passive_role =
- (rtc::SSL_SERVER == *dtls_role);
+ (SSL_SERVER == *dtls_role);
}
}
}
@@ -369,7 +367,7 @@
if (sdp_info_->local_description()) {
// Include all local ICE candidates in the SessionDescription unless
// the remote peer has requested an ICE restart.
- for (const cricket::MediaDescriptionOptions& options :
+ for (const MediaDescriptionOptions& options :
request.options.media_description_options) {
if (!options.transport_options.ice_restart) {
CopyCandidatesFromSessionDescription(sdp_info_->local_description(),
@@ -401,8 +399,7 @@
void WebRtcSessionDescriptionFactory::PostCreateSessionDescriptionFailed(
CreateSessionDescriptionObserver* observer,
RTCError error) {
- Post([observer =
- rtc::scoped_refptr<CreateSessionDescriptionObserver>(observer),
+ Post([observer = scoped_refptr<CreateSessionDescriptionObserver>(observer),
error]() mutable { observer->OnFailure(error); });
RTC_LOG(LS_ERROR) << "CreateSessionDescription failed: " << error.message();
}
@@ -410,8 +407,7 @@
void WebRtcSessionDescriptionFactory::PostCreateSessionDescriptionSucceeded(
CreateSessionDescriptionObserver* observer,
std::unique_ptr<SessionDescriptionInterface> description) {
- Post([observer =
- rtc::scoped_refptr<CreateSessionDescriptionObserver>(observer),
+ Post([observer = scoped_refptr<CreateSessionDescriptionObserver>(observer),
description = std::move(description)]() mutable {
observer->OnSuccess(description.release());
});
@@ -443,7 +439,7 @@
}
void WebRtcSessionDescriptionFactory::SetCertificate(
- rtc::scoped_refptr<RTCCertificate> certificate) {
+ scoped_refptr<RTCCertificate> certificate) {
RTC_DCHECK(certificate);
RTC_LOG(LS_VERBOSE) << "Setting new certificate.";
diff --git a/pc/webrtc_session_description_factory.h b/pc/webrtc_session_description_factory.h
index 580864e..3f3e6b6 100644
--- a/pc/webrtc_session_description_factory.h
+++ b/pc/webrtc_session_description_factory.h
@@ -52,8 +52,8 @@
const std::string& session_id,
bool dtls_enabled,
std::unique_ptr<RTCCertificateGeneratorInterface> cert_generator,
- rtc::scoped_refptr<RTCCertificate> certificate,
- std::function<void(const rtc::scoped_refptr<webrtc::RTCCertificate>&)>
+ scoped_refptr<RTCCertificate> certificate,
+ std::function<void(const webrtc::scoped_refptr<webrtc::RTCCertificate>&)>
on_certificate_ready,
CodecLookupHelper* codec_lookup_helper,
const FieldTrialsView& field_trials);
@@ -112,7 +112,7 @@
: type(type), observer(observer), options(options) {}
Type type;
- rtc::scoped_refptr<CreateSessionDescriptionObserver> observer;
+ scoped_refptr<CreateSessionDescriptionObserver> observer;
MediaSessionOptions options;
};
@@ -131,7 +131,7 @@
void Post(absl::AnyInvocable<void() &&> callback);
void OnCertificateRequestFailed();
- void SetCertificate(rtc::scoped_refptr<RTCCertificate> certificate);
+ void SetCertificate(scoped_refptr<RTCCertificate> certificate);
std::queue<CreateSessionDescriptionRequest>
create_session_description_requests_;
@@ -145,7 +145,7 @@
CertificateRequestState certificate_request_state_;
std::queue<absl::AnyInvocable<void() &&>> callbacks_;
- std::function<void(const rtc::scoped_refptr<webrtc::RTCCertificate>&)>
+ std::function<void(const webrtc::scoped_refptr<webrtc::RTCCertificate>&)>
on_certificate_ready_;
WeakPtrFactory<WebRtcSessionDescriptionFactory> weak_factory_{this};
