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

Remove not-needed webrtc:: prefixes in pc/

Browse Source 
This test drives the new tools_webrtc/remove_extra_namespace.py tool.

Bug: None
Change-Id: I9b590aa1213e4cace2d64d555f4dafd893f03606
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/327021
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41141}
This commit is contained in:
Harald Alvestrand 2023-11-13 09:33:56 +00:00 committed by WebRTC LUCI CQ
parent 9f0d10b1f4
commit a6544377bc
68 changed files with 1005 additions and 1003 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pc/audio_rtp_receiver.cc
View File

@ -278,7 +278,7 @@ std::vector<RtpSource> AudioRtpReceiver::GetSources() const {
}
void AudioRtpReceiver::SetDepacketizerToDecoderFrameTransformer(
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) {
rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) {
RTC_DCHECK_RUN_ON(worker_thread_);
if (media_channel_) {
media_channel_->SetDepacketizerToDecoderFrameTransformer(

3
pc/audio_rtp_receiver.h
View File

@ -118,8 +118,7 @@ class AudioRtpReceiver : public ObserverInterface,
std::vector<RtpSource> GetSources() const override;
int AttachmentId() const override { return attachment_id_; }
void SetDepacketizerToDecoderFrameTransformer(
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
override;
rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) override;
private:
void RestartMediaChannel(absl::optional<uint32_t> ssrc)

2
pc/audio_rtp_receiver_unittest.cc
View File

@ -98,7 +98,7 @@ TEST_F(AudioRtpReceiverTest, VolumesSetBeforeStartingAreRespected) {
// thread when a media channel pointer is passed to the receiver via the
// constructor.
TEST(AudioRtpReceiver, OnChangedNotificationsAfterConstruction) {
webrtc::test::RunLoop loop;
test::RunLoop loop;
auto* thread = rtc::Thread::Current(); // Points to loop's thread.
cricket::MockVoiceMediaReceiveChannelInterface receive_channel;
auto receiver = rtc::make_ref_counted<AudioRtpReceiver>(

2
pc/audio_track.h
View File

@ -58,7 +58,7 @@ class AudioTrack : public MediaStreamTrack<AudioTrackInterface>,
private:
const rtc::scoped_refptr<AudioSourceInterface> audio_source_;
RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker signaling_thread_checker_;
RTC_NO_UNIQUE_ADDRESS SequenceChecker signaling_thread_checker_;
};
} // namespace webrtc

2
pc/connection_context.h
View File

@ -138,7 +138,7 @@ class ConnectionContext final
RTC_GUARDED_BY(signaling_thread_);
std::unique_ptr<rtc::NetworkManager> default_network_manager_
RTC_GUARDED_BY(signaling_thread_);
std::unique_ptr<webrtc::CallFactoryInterface> const call_factory_
std::unique_ptr<CallFactoryInterface> const call_factory_
RTC_GUARDED_BY(worker_thread());
std::unique_ptr<rtc::PacketSocketFactory> default_socket_factory_

2
pc/data_channel_controller_unittest.cc
View File

@ -27,7 +27,7 @@ namespace {
using ::testing::NiceMock;
using ::testing::Return;
class MockDataChannelTransport : public webrtc::DataChannelTransportInterface {
class MockDataChannelTransport : public DataChannelTransportInterface {
public:
~MockDataChannelTransport() override {}

10
pc/data_channel_integrationtest.cc
View File

@ -90,7 +90,7 @@ class FakeClockForTest : public rtc::ScopedFakeClock {
// Some things use a time of "0" as a special value, so we need to start out
// the fake clock at a nonzero time.
// TODO(deadbeef): Fix this.
AdvanceTime(webrtc::TimeDelta::Seconds(1));
AdvanceTime(TimeDelta::Seconds(1));
}
// Explicit handle.
@ -422,7 +422,7 @@ TEST_P(DataChannelIntegrationTest, CalleeClosesSctpDataChannel) {
TEST_P(DataChannelIntegrationTest, SctpDataChannelConfigSentToOtherSide) {
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
webrtc::DataChannelInit init;
DataChannelInit init;
init.id = 53;
init.maxRetransmits = 52;
caller()->CreateDataChannel("data-channel", &init);
@ -453,7 +453,7 @@ TEST_P(DataChannelIntegrationTest, StressTestUnorderedSctpDataChannel) {
// Normal procedure, but with unordered data channel config.
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
webrtc::DataChannelInit init;
DataChannelInit init;
init.ordered = false;
caller()->CreateDataChannel(&init);
caller()->CreateAndSetAndSignalOffer();
@ -515,7 +515,7 @@ TEST_P(DataChannelIntegrationTest, StressTestOpenCloseChannelNoDelay) {
const size_t kIterations = 10;
bool has_negotiated = false;
webrtc::DataChannelInit init;
DataChannelInit init;
for (size_t repeats = 0; repeats < kIterations; ++repeats) {
RTC_LOG(LS_INFO) << "Iteration " << (repeats + 1) << "/" << kIterations;
@ -592,7 +592,7 @@ TEST_P(DataChannelIntegrationTest, StressTestOpenCloseChannelWithDelay) {
const size_t kIterations = 10;
bool has_negotiated = false;
webrtc::DataChannelInit init;
DataChannelInit init;
for (size_t repeats = 0; repeats < kIterations; ++repeats) {
RTC_LOG(LS_INFO) << "Iteration " << (repeats + 1) << "/" << kIterations;

17
pc/data_channel_unittest.cc
View File

@ -81,8 +81,7 @@ class SctpDataChannelTest : public ::testing::Test {
controller_(new FakeDataChannelController(&network_thread_)) {
network_thread_.Start();
inner_channel_ = controller_->CreateDataChannel("test", init_);
channel_ =
webrtc::SctpDataChannel::CreateProxy(inner_channel_, signaling_safety_);
channel_ = SctpDataChannel::CreateProxy(inner_channel_, signaling_safety_);
}
~SctpDataChannelTest() override {
run_loop_.Flush();
@ -510,7 +509,7 @@ TEST_F(SctpDataChannelTest, LateCreatedChannelTransitionToOpen) {
SetChannelReady();
InternalDataChannelInit init;
init.id = 1;
auto dc = webrtc::SctpDataChannel::CreateProxy(
auto dc = SctpDataChannel::CreateProxy(
controller_->CreateDataChannel("test1", init), signaling_safety_);
EXPECT_EQ(DataChannelInterface::kOpen, dc->state());
}
@ -524,7 +523,7 @@ TEST_F(SctpDataChannelTest, SendUnorderedAfterReceivesOpenAck) {
init.ordered = false;
rtc::scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", init);
auto proxy = webrtc::SctpDataChannel::CreateProxy(dc, signaling_safety_);
auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
@ -553,7 +552,7 @@ TEST_F(SctpDataChannelTest, DeprecatedSendUnorderedAfterReceivesOpenAck) {
init.ordered = false;
rtc::scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", init);
auto proxy = webrtc::SctpDataChannel::CreateProxy(dc, signaling_safety_);
auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
@ -582,7 +581,7 @@ TEST_F(SctpDataChannelTest, SendUnorderedAfterReceiveData) {
init.ordered = false;
rtc::scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", init);
auto proxy = webrtc::SctpDataChannel::CreateProxy(dc, signaling_safety_);
auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
@ -605,7 +604,7 @@ TEST_F(SctpDataChannelTest, DeprecatedSendUnorderedAfterReceiveData) {
init.ordered = false;
rtc::scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", init);
auto proxy = webrtc::SctpDataChannel::CreateProxy(dc, signaling_safety_);
auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
@ -714,7 +713,7 @@ TEST_F(SctpDataChannelTest, NoMsgSentIfNegotiatedAndNotFromOpenMsg) {
SetChannelReady();
rtc::scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", config);
auto proxy = webrtc::SctpDataChannel::CreateProxy(dc, signaling_safety_);
auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
EXPECT_EQ(0, controller_->last_sid());
@ -779,7 +778,7 @@ TEST_F(SctpDataChannelTest, OpenAckSentIfCreatedFromOpenMessage) {
SetChannelReady();
rtc::scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", config);
auto proxy = webrtc::SctpDataChannel::CreateProxy(dc, signaling_safety_);
auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);

7
pc/ice_server_parsing_unittest.cc
View File

@ -62,9 +62,7 @@ class IceServerParsingTest : public ::testing::Test {
server.tls_cert_policy = tls_certificate_policy;
server.hostname = hostname;
servers.push_back(server);
return webrtc::ParseIceServersOrError(servers, &stun_servers_,
&turn_servers_)
.ok();
return ParseIceServersOrError(servers, &stun_servers_, &turn_servers_).ok();
}
protected:
@ -233,8 +231,7 @@ TEST_F(IceServerParsingTest, ParseMultipleUrls) {
server.password = "bar";
servers.push_back(server);
EXPECT_TRUE(
webrtc::ParseIceServersOrError(servers, &stun_servers_, &turn_servers_)
.ok());
ParseIceServersOrError(servers, &stun_servers_, &turn_servers_).ok());
EXPECT_EQ(1U, stun_servers_.size());
EXPECT_EQ(1U, turn_servers_.size());
}

2
pc/ice_transport_unittest.cc
View File

@ -32,7 +32,7 @@ class IceTransportTest : public ::testing::Test {
rtc::SocketServer* socket_server() const { return socket_server_.get(); }
webrtc::test::ScopedKeyValueConfig field_trials_;
test::ScopedKeyValueConfig field_trials_;
private:
std::unique_ptr<rtc::SocketServer> socket_server_;

34
pc/jsep_transport_controller.cc
View File

@ -148,7 +148,7 @@ JsepTransportController::GetRtcpDtlsTransport(const std::string& mid) const {
return jsep_transport->rtcp_dtls_transport();
}
rtc::scoped_refptr<webrtc::DtlsTransport>
rtc::scoped_refptr<DtlsTransport>
JsepTransportController::LookupDtlsTransportByMid(const std::string& mid) {
RTC_DCHECK_RUN_ON(network_thread_);
auto jsep_transport = GetJsepTransportForMid(mid);
@ -383,7 +383,7 @@ RTCError JsepTransportController::RollbackTransports() {
return RTCError::OK();
}
rtc::scoped_refptr<webrtc::IceTransportInterface>
rtc::scoped_refptr<IceTransportInterface>
JsepTransportController::CreateIceTransport(const std::string& transport_name,
bool rtcp) {
int component = rtcp ? cricket::ICE_CANDIDATE_COMPONENT_RTCP
@ -455,7 +455,7 @@ JsepTransportController::CreateDtlsTransport(
return dtls;
}
std::unique_ptr<webrtc::RtpTransport>
std::unique_ptr<RtpTransport>
JsepTransportController::CreateUnencryptedRtpTransport(
const std::string& transport_name,
rtc::PacketTransportInternal* rtp_packet_transport,
@ -470,13 +470,12 @@ JsepTransportController::CreateUnencryptedRtpTransport(
return unencrypted_rtp_transport;
}
std::unique_ptr<webrtc::SrtpTransport>
JsepTransportController::CreateSdesTransport(
std::unique_ptr<SrtpTransport> JsepTransportController::CreateSdesTransport(
const std::string& transport_name,
cricket::DtlsTransportInternal* rtp_dtls_transport,
cricket::DtlsTransportInternal* rtcp_dtls_transport) {
RTC_DCHECK_RUN_ON(network_thread_);
auto srtp_transport = std::make_unique<webrtc::SrtpTransport>(
auto srtp_transport = std::make_unique<SrtpTransport>(
rtcp_dtls_transport == nullptr, *config_.field_trials);
RTC_DCHECK(rtp_dtls_transport);
srtp_transport->SetRtpPacketTransport(rtp_dtls_transport);
@ -489,13 +488,13 @@ JsepTransportController::CreateSdesTransport(
return srtp_transport;
}
std::unique_ptr<webrtc::DtlsSrtpTransport>
std::unique_ptr<DtlsSrtpTransport>
JsepTransportController::CreateDtlsSrtpTransport(
const std::string& transport_name,
cricket::DtlsTransportInternal* rtp_dtls_transport,
cricket::DtlsTransportInternal* rtcp_dtls_transport) {
RTC_DCHECK_RUN_ON(network_thread_);
auto dtls_srtp_transport = std::make_unique<webrtc::DtlsSrtpTransport>(
auto dtls_srtp_transport = std::make_unique<DtlsSrtpTransport>(
rtcp_dtls_transport == nullptr, *config_.field_trials);
if (config_.enable_external_auth) {
dtls_srtp_transport->EnableExternalAuth();
@ -985,13 +984,12 @@ int JsepTransportController::GetRtpAbsSendTimeHeaderExtensionId(
const cricket::MediaContentDescription* content_desc =
content_info.media_description();
const webrtc::RtpExtension* send_time_extension =
webrtc::RtpExtension::FindHeaderExtensionByUri(
content_desc->rtp_header_extensions(),
webrtc::RtpExtension::kAbsSendTimeUri,
const RtpExtension* send_time_extension =
RtpExtension::FindHeaderExtensionByUri(
content_desc->rtp_header_extensions(), RtpExtension::kAbsSendTimeUri,
config_.crypto_options.srtp.enable_encrypted_rtp_header_extensions
? webrtc::RtpExtension::kPreferEncryptedExtension
: webrtc::RtpExtension::kDiscardEncryptedExtension);
? RtpExtension::kPreferEncryptedExtension
: RtpExtension::kDiscardEncryptedExtension);
return send_time_extension ? send_time_extension->id : -1;
}
@ -1039,7 +1037,7 @@ RTCError JsepTransportController::MaybeCreateJsepTransport(
"SDES and DTLS-SRTP cannot be enabled at the same time.");
}
rtc::scoped_refptr<webrtc::IceTransportInterface> ice =
rtc::scoped_refptr<IceTransportInterface> ice =
CreateIceTransport(content_info.name, /*rtcp=*/false);
std::unique_ptr<cricket::DtlsTransportInternal> rtp_dtls_transport =
@ -1050,7 +1048,7 @@ RTCError JsepTransportController::MaybeCreateJsepTransport(
std::unique_ptr<SrtpTransport> sdes_transport;
std::unique_ptr<DtlsSrtpTransport> dtls_srtp_transport;
rtc::scoped_refptr<webrtc::IceTransportInterface> rtcp_ice;
rtc::scoped_refptr<IceTransportInterface> rtcp_ice;
if (config_.rtcp_mux_policy !=
PeerConnectionInterface::kRtcpMuxPolicyRequire &&
content_info.type == cricket::MediaProtocolType::kRtp) {
@ -1096,7 +1094,7 @@ RTCError JsepTransportController::MaybeCreateJsepTransport(
OnRtcpPacketReceived_n(buffer, packet_time_ms);
});
jsep_transport->rtp_transport()->SetUnDemuxableRtpPacketReceivedHandler(
[this](webrtc::RtpPacketReceived& packet) {
[this](RtpPacketReceived& packet) {
RTC_DCHECK_RUN_ON(network_thread_);
OnUnDemuxableRtpPacketReceived_n(packet);
});
@ -1421,7 +1419,7 @@ void JsepTransportController::OnRtcpPacketReceived_n(
}
void JsepTransportController::OnUnDemuxableRtpPacketReceived_n(
const webrtc::RtpPacketReceived& packet) {
const RtpPacketReceived& packet) {
RTC_DCHECK(config_.un_demuxable_packet_handler);
config_.un_demuxable_packet_handler(packet);
}

18
pc/jsep_transport_controller.h
View File

@ -112,7 +112,7 @@ class JsepTransportController : public sigslot::has_slots<> {
rtc::SSLProtocolVersion ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
// `crypto_options` is used to determine if created DTLS transports
// negotiate GCM crypto suites or not.
webrtc::CryptoOptions crypto_options;
CryptoOptions crypto_options;
PeerConnectionInterface::BundlePolicy bundle_policy =
PeerConnectionInterface::kBundlePolicyBalanced;
PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy =
@ -120,7 +120,7 @@ class JsepTransportController : public sigslot::has_slots<> {
bool disable_encryption = false;
bool enable_external_auth = false;
// Used to inject the ICE/DTLS transports created externally.
webrtc::IceTransportFactory* ice_transport_factory = nullptr;
IceTransportFactory* ice_transport_factory = nullptr;
cricket::DtlsTransportFactory* dtls_transport_factory = nullptr;
Observer* transport_observer = nullptr;
// Must be provided and valid for the lifetime of the
@ -140,7 +140,7 @@ class JsepTransportController : public sigslot::has_slots<> {
std::function<void(rtc::SSLHandshakeError)> on_dtls_handshake_error_;
// Field trials.
const webrtc::FieldTrialsView* field_trials;
const FieldTrialsView* field_trials;
};
// The ICE related events are fired on the `network_thread`.
@ -174,7 +174,7 @@ class JsepTransportController : public sigslot::has_slots<> {
const cricket::DtlsTransportInternal* GetRtcpDtlsTransport(
const std::string& mid) const;
// Gets the externally sharable version of the DtlsTransport.
rtc::scoped_refptr<webrtc::DtlsTransport> LookupDtlsTransportByMid(
rtc::scoped_refptr<DtlsTransport> LookupDtlsTransportByMid(
const std::string& mid);
rtc::scoped_refptr<SctpTransport> GetSctpTransport(
const std::string& mid) const;
@ -399,19 +399,19 @@ class JsepTransportController : public sigslot::has_slots<> {
std::unique_ptr<cricket::DtlsTransportInternal> CreateDtlsTransport(
const cricket::ContentInfo& content_info,
cricket::IceTransportInternal* ice);
rtc::scoped_refptr<webrtc::IceTransportInterface> CreateIceTransport(
rtc::scoped_refptr<IceTransportInterface> CreateIceTransport(
const std::string& transport_name,
bool rtcp);
std::unique_ptr<webrtc::RtpTransport> CreateUnencryptedRtpTransport(
std::unique_ptr<RtpTransport> CreateUnencryptedRtpTransport(
const std::string& transport_name,
rtc::PacketTransportInternal* rtp_packet_transport,
rtc::PacketTransportInternal* rtcp_packet_transport);
std::unique_ptr<webrtc::SrtpTransport> CreateSdesTransport(
std::unique_ptr<SrtpTransport> CreateSdesTransport(
const std::string& transport_name,
cricket::DtlsTransportInternal* rtp_dtls_transport,
cricket::DtlsTransportInternal* rtcp_dtls_transport);
std::unique_ptr<webrtc::DtlsSrtpTransport> CreateDtlsSrtpTransport(
std::unique_ptr<DtlsSrtpTransport> CreateDtlsSrtpTransport(
const std::string& transport_name,
cricket::DtlsTransportInternal* rtp_dtls_transport,
cricket::DtlsTransportInternal* rtcp_dtls_transport);
@ -453,7 +453,7 @@ class JsepTransportController : public sigslot::has_slots<> {
void OnRtcpPacketReceived_n(rtc::CopyOnWriteBuffer* packet,
int64_t packet_time_us)
RTC_RUN_ON(network_thread_);
void OnUnDemuxableRtpPacketReceived_n(const webrtc::RtpPacketReceived& packet)
void OnUnDemuxableRtpPacketReceived_n(const RtpPacketReceived& packet)
RTC_RUN_ON(network_thread_);
void OnDtlsHandshakeError(rtc::SSLHandshakeError error);

10
pc/jsep_transport_controller_unittest.cc
View File

@ -56,7 +56,7 @@ static const char kDataMid1[] = "data1";
namespace webrtc {
class FakeIceTransportFactory : public webrtc::IceTransportFactory {
class FakeIceTransportFactory : public IceTransportFactory {
public:
~FakeIceTransportFactory() override = default;
rtc::scoped_refptr<IceTransportInterface> CreateIceTransport(
@ -72,7 +72,7 @@ class FakeDtlsTransportFactory : public cricket::DtlsTransportFactory {
public:
std::unique_ptr<cricket::DtlsTransportInternal> CreateDtlsTransport(
cricket::IceTransportInternal* ice,
const webrtc::CryptoOptions& crypto_options,
const CryptoOptions& crypto_options,
rtc::SSLProtocolVersion max_version) override {
return std::make_unique<FakeDtlsTransport>(
static_cast<cricket::FakeIceTransport*>(ice));
@ -379,7 +379,7 @@ class JsepTransportControllerTest : public JsepTransportController::Observer,
// Transport controller needs to be destroyed first, because it may issue
// callbacks that modify the changed_*_by_mid in the destructor.
std::unique_ptr<JsepTransportController> transport_controller_;
webrtc::test::ScopedKeyValueConfig field_trials_;
test::ScopedKeyValueConfig field_trials_;
};
TEST_F(JsepTransportControllerTest, GetRtpTransport) {
@ -425,7 +425,7 @@ TEST_F(JsepTransportControllerTest, GetDtlsTransport) {
// and verify that the resulting container is empty.
auto dtls_transport =
transport_controller_->LookupDtlsTransportByMid(kVideoMid1);
webrtc::DtlsTransport* my_transport =
DtlsTransport* my_transport =
static_cast<DtlsTransport*>(dtls_transport.get());
EXPECT_NE(nullptr, my_transport->internal());
transport_controller_.reset();
@ -899,7 +899,7 @@ TEST_F(JsepTransportControllerTest,
transport_controller_->GetDtlsTransport(kAudioMid1));
fake_audio_dtls->fake_ice_transport()->MaybeStartGathering();
fake_audio_dtls->fake_ice_transport()->SetTransportState(
webrtc::IceTransportState::kChecking,
IceTransportState::kChecking,
cricket::IceTransportState::STATE_CONNECTING);
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionChecking,
ice_connection_state_, kTimeout);

12
pc/legacy_stats_collector.cc
View File

@ -355,9 +355,8 @@ void ExtractStats(const cricket::VideoReceiverInfo& info,
report->AddInt64(StatsReport::kStatsValueNameInterframeDelayMaxMs,
info.interframe_delay_max_ms);
report->AddString(
StatsReport::kStatsValueNameContentType,
webrtc::videocontenttypehelpers::ToString(info.content_type));
report->AddString(StatsReport::kStatsValueNameContentType,
videocontenttypehelpers::ToString(info.content_type));
}
void ExtractStats(const cricket::VideoSenderInfo& info,
@ -398,9 +397,8 @@ void ExtractStats(const cricket::VideoSenderInfo& info,
for (const auto& i : ints)
report->AddInt(i.name, i.value);
report->AddString(StatsReport::kStatsValueNameMediaType, "video");
report->AddString(
StatsReport::kStatsValueNameContentType,
webrtc::videocontenttypehelpers::ToString(info.content_type));
report->AddString(StatsReport::kStatsValueNameContentType,
videocontenttypehelpers::ToString(info.content_type));
}
void ExtractStats(const cricket::BandwidthEstimationInfo& info,
@ -1033,7 +1031,7 @@ void LegacyStatsCollector::ExtractBweInfo() {
if (pc_->signaling_state() == PeerConnectionInterface::kClosed)
return;
webrtc::Call::Stats call_stats = pc_->GetCallStats();
Call::Stats call_stats = pc_->GetCallStats();
cricket::BandwidthEstimationInfo bwe_info;
bwe_info.available_send_bandwidth = call_stats.send_bandwidth_bps;
bwe_info.available_recv_bandwidth = call_stats.recv_bandwidth_bps;

6
pc/legacy_stats_collector.h
View File

@ -177,9 +177,9 @@ class LegacyStatsCollector : public LegacyStatsCollectorInterface {
void ExtractMediaInfo(
const std::map<std::string, std::string>& transport_names_by_mid);
void ExtractSenderInfo();
webrtc::StatsReport* GetReport(const StatsReport::StatsType& type,
const std::string& id,
StatsReport::Direction direction);
StatsReport* GetReport(const StatsReport::StatsType& type,
const std::string& id,
StatsReport::Direction direction);
// Helper method to get stats from the local audio tracks.
void UpdateStatsFromExistingLocalAudioTracks(bool has_remote_tracks);

10
pc/media_stream_unittest.cc
View File

@ -91,7 +91,7 @@ TEST_F(MediaStreamTest, GetTrackInfo) {
ASSERT_EQ(1u, stream_->GetAudioTracks().size());
// Verify the video track.
scoped_refptr<webrtc::MediaStreamTrackInterface> video_track(
scoped_refptr<MediaStreamTrackInterface> video_track(
stream_->GetVideoTracks()[0]);
EXPECT_EQ(0, video_track->id().compare(kVideoTrackId));
EXPECT_TRUE(video_track->enabled());
@ -105,7 +105,7 @@ TEST_F(MediaStreamTest, GetTrackInfo) {
EXPECT_TRUE(video_track->enabled());
// Verify the audio track.
scoped_refptr<webrtc::MediaStreamTrackInterface> audio_track(
scoped_refptr<MediaStreamTrackInterface> audio_track(
stream_->GetAudioTracks()[0]);
EXPECT_EQ(0, audio_track->id().compare(kAudioTrackId));
EXPECT_TRUE(audio_track->enabled());
@ -139,14 +139,12 @@ TEST_F(MediaStreamTest, RemoveTrack) {
}
TEST_F(MediaStreamTest, ChangeVideoTrack) {
scoped_refptr<webrtc::VideoTrackInterface> video_track(
stream_->GetVideoTracks()[0]);
scoped_refptr<VideoTrackInterface> video_track(stream_->GetVideoTracks()[0]);
ChangeTrack(video_track.get());
}
TEST_F(MediaStreamTest, ChangeAudioTrack) {
scoped_refptr<webrtc::AudioTrackInterface> audio_track(
stream_->GetAudioTracks()[0]);
scoped_refptr<AudioTrackInterface> audio_track(stream_->GetAudioTracks()[0]);
ChangeTrack(audio_track.get());
}

12
pc/peer_connection.cc
View File

@ -185,7 +185,7 @@ IceCandidatePairType GetIceCandidatePairCounter(
absl::optional<int> RTCConfigurationToIceConfigOptionalInt(
int rtc_configuration_parameter) {
if (rtc_configuration_parameter ==
webrtc::PeerConnectionInterface::RTCConfiguration::kUndefined) {
PeerConnectionInterface::RTCConfiguration::kUndefined) {
return absl::nullopt;
}
return rtc_configuration_parameter;
@ -449,7 +449,7 @@ bool PeerConnectionInterface::RTCConfiguration::operator==(
absl::optional<int> ice_unwritable_min_checks;
absl::optional<int> ice_inactive_timeout;
absl::optional<int> stun_candidate_keepalive_interval;
webrtc::TurnCustomizer* turn_customizer;
TurnCustomizer* turn_customizer;
SdpSemantics sdp_semantics;
absl::optional<rtc::AdapterType> network_preference;
bool active_reset_srtp_params;
@ -459,7 +459,7 @@ bool PeerConnectionInterface::RTCConfiguration::operator==(
bool enable_implicit_rollback;
absl::optional<int> report_usage_pattern_delay_ms;
absl::optional<int> stable_writable_connection_ping_interval_ms;
webrtc::VpnPreference vpn_preference;
VpnPreference vpn_preference;
std::vector<rtc::NetworkMask> vpn_list;
PortAllocatorConfig port_allocator_config;
absl::optional<TimeDelta> pacer_burst_interval;
@ -1685,7 +1685,7 @@ void PeerConnection::AddIceCandidate(
std::function<void(RTCError)> callback) {
RTC_DCHECK_RUN_ON(signaling_thread());
sdp_handler_->AddIceCandidate(std::move(candidate),
[this, callback](webrtc::RTCError result) {
[this, callback](RTCError result) {
ClearStatsCache();
callback(result);
});
@ -1789,7 +1789,7 @@ bool PeerConnection::StartRtcEventLog(
std::unique_ptr<RtcEventLogOutput> output) {
int64_t output_period_ms = 5000;
if (trials().IsDisabled("WebRTC-RtcEventLogNewFormat")) {
output_period_ms = webrtc::RtcEventLog::kImmediateOutput;
output_period_ms = RtcEventLog::kImmediateOutput;
}
return StartRtcEventLog(std::move(output), output_period_ms);
}
@ -2222,7 +2222,7 @@ bool PeerConnection::ReconfigurePortAllocator_n(
IceTransportsType type,
int candidate_pool_size,
PortPrunePolicy turn_port_prune_policy,
webrtc::TurnCustomizer* turn_customizer,
TurnCustomizer* turn_customizer,
absl::optional<int> stun_candidate_keepalive_interval,
bool have_local_description) {
RTC_DCHECK_RUN_ON(network_thread());

8
pc/peer_connection.h
View File

@ -163,7 +163,7 @@ class PeerConnection : public PeerConnectionInternal,
const DataChannelInit* config) override;
// WARNING: LEGACY. See peerconnectioninterface.h
bool GetStats(StatsObserver* observer,
webrtc::MediaStreamTrackInterface* track,
MediaStreamTrackInterface* track,
StatsOutputLevel level) override;
// Spec-complaint GetStats(). See peerconnectioninterface.h
void GetStats(RTCStatsCollectorCallback* callback) override;
@ -510,7 +510,7 @@ class PeerConnection : public PeerConnectionInternal,
IceTransportsType type,
int candidate_pool_size,
PortPrunePolicy turn_port_prune_policy,
webrtc::TurnCustomizer* turn_customizer,
TurnCustomizer* turn_customizer,
absl::optional<int> stun_candidate_keepalive_interval,
bool have_local_description);
@ -602,7 +602,7 @@ class PeerConnection : public PeerConnectionInternal,
// a) Specified in PeerConnectionDependencies (owned).
// b) Accessed via ConnectionContext (e.g PeerConnectionFactoryDependencies>
// c) Created as Default (FieldTrialBasedConfig).
const webrtc::AlwaysValidPointer<const FieldTrialsView, FieldTrialBasedConfig>
const AlwaysValidPointer<const FieldTrialsView, FieldTrialBasedConfig>
trials_;
const PeerConnectionFactoryInterface::Options options_;
PeerConnectionObserver* observer_ RTC_GUARDED_BY(signaling_thread()) =
@ -634,7 +634,7 @@ class PeerConnection : public PeerConnectionInternal,
std::unique_ptr<cricket::PortAllocator>
port_allocator_; // TODO(bugs.webrtc.org/9987): Accessed on both
// signaling and network thread.
const std::unique_ptr<webrtc::IceTransportFactory>
const std::unique_ptr<IceTransportFactory>
ice_transport_factory_; // TODO(bugs.webrtc.org/9987): Accessed on the
// signaling thread but the underlying raw
// pointer is given to

2
pc/peer_connection_crypto_unittest.cc
View File

@ -162,7 +162,7 @@ class PeerConnectionCryptoBaseTest : public ::testing::Test {
return transport_info->description.connection_role;
}
webrtc::test::ScopedKeyValueConfig field_trials_;
test::ScopedKeyValueConfig field_trials_;
std::unique_ptr<rtc::VirtualSocketServer> vss_;
rtc::AutoSocketServerThread main_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;

214
pc/peer_connection_encodings_integrationtest.cc
View File

@ -77,18 +77,17 @@ struct StringParamToString {
// RTX, RED and FEC are reliability mechanisms used in combinations with other
// codecs, but are not themselves a specific codec. Typically you don't want to
// filter these out of the list of codec preferences.
bool IsReliabilityMechanism(const webrtc::RtpCodecCapability& codec) {
bool IsReliabilityMechanism(const RtpCodecCapability& codec) {
return absl::EqualsIgnoreCase(codec.name, cricket::kRtxCodecName) ||
absl::EqualsIgnoreCase(codec.name, cricket::kRedCodecName) ||
absl::EqualsIgnoreCase(codec.name, cricket::kUlpfecCodecName);
}
std::string GetCurrentCodecMimeType(
rtc::scoped_refptr<const webrtc::RTCStatsReport> report,
const webrtc::RTCOutboundRtpStreamStats& outbound_rtp) {
rtc::scoped_refptr<const RTCStatsReport> report,
const RTCOutboundRtpStreamStats& outbound_rtp) {
return outbound_rtp.codec_id.is_defined()
? *report->GetAs<webrtc::RTCCodecStats>(*outbound_rtp.codec_id)
->mime_type
? *report->GetAs<RTCCodecStats>(*outbound_rtp.codec_id)->mime_type
: "";
}
@ -98,8 +97,8 @@ struct RidAndResolution {
uint32_t height;
};
const webrtc::RTCOutboundRtpStreamStats* FindOutboundRtpByRid(
const std::vector<const webrtc::RTCOutboundRtpStreamStats*>& outbound_rtps,
const RTCOutboundRtpStreamStats* FindOutboundRtpByRid(
const std::vector<const RTCOutboundRtpStreamStats*>& outbound_rtps,
const absl::string_view& rid) {
for (const auto* outbound_rtp : outbound_rtps) {
if (outbound_rtp->rid.is_defined() && *outbound_rtp->rid == rid) {
@ -121,8 +120,8 @@ class PeerConnectionEncodingsIntegrationTest : public ::testing::Test {
rtc::scoped_refptr<PeerConnectionTestWrapper> CreatePc() {
auto pc_wrapper = rtc::make_ref_counted<PeerConnectionTestWrapper>(
"pc", &pss_, background_thread_.get(), background_thread_.get());
pc_wrapper->CreatePc({}, webrtc::CreateBuiltinAudioEncoderFactory(),
webrtc::CreateBuiltinAudioDecoderFactory());
pc_wrapper->CreatePc({}, CreateBuiltinAudioEncoderFactory(),
CreateBuiltinAudioDecoderFactory());
return pc_wrapper;
}
@ -130,10 +129,9 @@ class PeerConnectionEncodingsIntegrationTest : public ::testing::Test {
rtc::scoped_refptr<PeerConnectionTestWrapper> local,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote,
std::vector<cricket::SimulcastLayer> init_layers) {
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
local->GetUserMedia(
/*audio=*/false, cricket::AudioOptions(), /*video=*/true,
{.width = 1280, .height = 720});
rtc::scoped_refptr<MediaStreamInterface> stream = local->GetUserMedia(
/*audio=*/false, cricket::AudioOptions(), /*video=*/true,
{.width = 1280, .height = 720});
rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
@ -973,8 +971,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->pc()->AddTransceiver(cricket::MEDIA_TYPE_AUDIO);
rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters =
audio_transceiver->sender()->GetParameters();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
EXPECT_FALSE(parameters.encodings[0].codec.has_value());
}
@ -986,8 +983,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->pc()->AddTransceiver(cricket::MEDIA_TYPE_VIDEO);
rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters =
video_transceiver->sender()->GetParameters();
RtpParameters parameters = video_transceiver->sender()->GetParameters();
EXPECT_FALSE(parameters.encodings[0].codec.has_value());
}
@ -997,19 +993,19 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
rtc::scoped_refptr<MediaStreamInterface> stream =
local_pc_wrapper->GetUserMedia(
/*audio=*/true, {}, /*video=*/false, {});
rtc::scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0];
absl::optional<webrtc::RtpCodecCapability> pcmu =
absl::optional<RtpCodecCapability> pcmu =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"pcmu");
ASSERT_TRUE(pcmu);
webrtc::RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
init.direction = RtpTransceiverDirection::kSendOnly;
RtpEncodingParameters encoding_parameters;
encoding_parameters.codec = pcmu;
init.send_encodings.push_back(encoding_parameters);
@ -1017,8 +1013,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->pc()->AddTransceiver(track, init);
rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters =
audio_transceiver->sender()->GetParameters();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
EXPECT_EQ(*parameters.encodings[0].codec, *pcmu);
NegotiateWithSimulcastTweaks(local_pc_wrapper, remote_pc_wrapper);
@ -1039,19 +1034,19 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
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];
absl::optional<webrtc::RtpCodecCapability> vp9 =
absl::optional<RtpCodecCapability> vp9 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp9");
ASSERT_TRUE(vp9);
webrtc::RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
init.direction = RtpTransceiverDirection::kSendOnly;
RtpEncodingParameters encoding_parameters;
encoding_parameters.codec = vp9;
encoding_parameters.scalability_mode = "L3T3";
init.send_encodings.push_back(encoding_parameters);
@ -1060,8 +1055,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->pc()->AddTransceiver(track, init);
rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters =
audio_transceiver->sender()->GetParameters();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
EXPECT_EQ(*parameters.encodings[0].codec, *vp9);
NegotiateWithSimulcastTweaks(local_pc_wrapper, remote_pc_wrapper);
@ -1087,20 +1081,19 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
rtc::scoped_refptr<MediaStreamInterface> stream =
local_pc_wrapper->GetUserMedia(
/*audio=*/true, {}, /*video=*/false, {});
rtc::scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0];
absl::optional<webrtc::RtpCodecCapability> pcmu =
absl::optional<RtpCodecCapability> pcmu =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"pcmu");
auto transceiver_or_error = local_pc_wrapper->pc()->AddTransceiver(track);
rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters =
audio_transceiver->sender()->GetParameters();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = pcmu;
EXPECT_TRUE(audio_transceiver->sender()->SetParameters(parameters).ok());
@ -1125,12 +1118,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
rtc::scoped_refptr<MediaStreamInterface> stream =
local_pc_wrapper->GetUserMedia(
/*audio=*/true, {}, /*video=*/false, {});
rtc::scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0];
absl::optional<webrtc::RtpCodecCapability> pcmu =
absl::optional<RtpCodecCapability> pcmu =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"pcmu");
@ -1150,8 +1143,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
EXPECT_STRCASENE(("audio/" + pcmu->name).c_str(), codec_name.c_str());
std::string last_codec_id = outbound_rtps[0]->codec_id.value();
webrtc::RtpParameters parameters =
audio_transceiver->sender()->GetParameters();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = pcmu;
EXPECT_TRUE(audio_transceiver->sender()->SetParameters(parameters).ok());
@ -1174,20 +1166,19 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
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];
absl::optional<webrtc::RtpCodecCapability> vp9 =
absl::optional<RtpCodecCapability> vp9 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp9");
auto transceiver_or_error = local_pc_wrapper->pc()->AddTransceiver(track);
rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters =
video_transceiver->sender()->GetParameters();
RtpParameters parameters = video_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = vp9;
parameters.encodings[0].scalability_mode = "L3T3";
EXPECT_TRUE(video_transceiver->sender()->SetParameters(parameters).ok());
@ -1218,12 +1209,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
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];
absl::optional<webrtc::RtpCodecCapability> vp9 =
absl::optional<RtpCodecCapability> vp9 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp9");
@ -1243,8 +1234,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
EXPECT_STRCASENE(("audio/" + vp9->name).c_str(), codec_name.c_str());
std::string last_codec_id = outbound_rtps[0]->codec_id.value();
webrtc::RtpParameters parameters =
video_transceiver->sender()->GetParameters();
RtpParameters parameters = video_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = vp9;
parameters.encodings[0].scalability_mode = "L3T3";
EXPECT_TRUE(video_transceiver->sender()->SetParameters(parameters).ok());
@ -1269,15 +1259,15 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
AddTransceiverRejectsUnknownCodecParameterAudio) {
rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
webrtc::RtpCodec dummy_codec;
RtpCodec dummy_codec;
dummy_codec.kind = cricket::MEDIA_TYPE_AUDIO;
dummy_codec.name = "FOOBAR";
dummy_codec.clock_rate = 90000;
dummy_codec.num_channels = 2;
webrtc::RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
init.direction = RtpTransceiverDirection::kSendOnly;
RtpEncodingParameters encoding_parameters;
encoding_parameters.codec = dummy_codec;
init.send_encodings.push_back(encoding_parameters);
@ -1292,14 +1282,14 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
AddTransceiverRejectsUnknownCodecParameterVideo) {
rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
webrtc::RtpCodec dummy_codec;
RtpCodec dummy_codec;
dummy_codec.kind = cricket::MEDIA_TYPE_VIDEO;
dummy_codec.name = "FOOBAR";
dummy_codec.clock_rate = 90000;
webrtc::RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
init.direction = RtpTransceiverDirection::kSendOnly;
RtpEncodingParameters encoding_parameters;
encoding_parameters.codec = dummy_codec;
init.send_encodings.push_back(encoding_parameters);
@ -1314,7 +1304,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsUnknownCodecParameterAudio) {
rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
webrtc::RtpCodec dummy_codec;
RtpCodec dummy_codec;
dummy_codec.kind = cricket::MEDIA_TYPE_AUDIO;
dummy_codec.name = "FOOBAR";
dummy_codec.clock_rate = 90000;
@ -1326,8 +1316,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters =
audio_transceiver->sender()->GetParameters();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = dummy_codec;
RTCError error = audio_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1337,7 +1326,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsUnknownCodecParameterVideo) {
rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
webrtc::RtpCodec dummy_codec;
RtpCodec dummy_codec;
dummy_codec.kind = cricket::MEDIA_TYPE_VIDEO;
dummy_codec.name = "FOOBAR";
dummy_codec.clock_rate = 90000;
@ -1348,8 +1337,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters =
video_transceiver->sender()->GetParameters();
RtpParameters parameters = video_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = dummy_codec;
RTCError error = video_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1359,12 +1347,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsNonPreferredCodecParameterAudio) {
rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
absl::optional<webrtc::RtpCodecCapability> opus =
absl::optional<RtpCodecCapability> opus =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"opus");
ASSERT_TRUE(opus);
std::vector<webrtc::RtpCodecCapability> not_opus_codecs =
std::vector<RtpCodecCapability> not_opus_codecs =
local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
.codecs;
@ -1382,8 +1370,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
transceiver_or_error.MoveValue();
ASSERT_TRUE(audio_transceiver->SetCodecPreferences(not_opus_codecs).ok());
webrtc::RtpParameters parameters =
audio_transceiver->sender()->GetParameters();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = opus;
RTCError error = audio_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1393,12 +1380,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsNonPreferredCodecParameterVideo) {
rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
absl::optional<webrtc::RtpCodecCapability> vp8 =
absl::optional<RtpCodecCapability> vp8 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp8");
ASSERT_TRUE(vp8);
std::vector<webrtc::RtpCodecCapability> not_vp8_codecs =
std::vector<RtpCodecCapability> not_vp8_codecs =
local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO)
.codecs;
@ -1416,8 +1403,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
transceiver_or_error.MoveValue();
ASSERT_TRUE(video_transceiver->SetCodecPreferences(not_vp8_codecs).ok());
webrtc::RtpParameters parameters =
video_transceiver->sender()->GetParameters();
RtpParameters parameters = video_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = vp8;
RTCError error = video_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1429,12 +1415,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
absl::optional<webrtc::RtpCodecCapability> opus =
absl::optional<RtpCodecCapability> opus =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"opus");
ASSERT_TRUE(opus);
std::vector<webrtc::RtpCodecCapability> not_opus_codecs =
std::vector<RtpCodecCapability> not_opus_codecs =
local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
.codecs;
@ -1456,8 +1442,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection();
webrtc::RtpParameters parameters =
audio_transceiver->sender()->GetParameters();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = opus;
RTCError error = audio_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1469,12 +1454,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
absl::optional<webrtc::RtpCodecCapability> opus =
absl::optional<RtpCodecCapability> opus =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"opus");
ASSERT_TRUE(opus);
std::vector<webrtc::RtpCodecCapability> not_opus_codecs =
std::vector<RtpCodecCapability> not_opus_codecs =
local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
.codecs;
@ -1519,8 +1504,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection();
webrtc::RtpParameters parameters =
audio_transceiver->sender()->GetParameters();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = opus;
RTCError error = audio_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1532,12 +1516,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
absl::optional<webrtc::RtpCodecCapability> vp8 =
absl::optional<RtpCodecCapability> vp8 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp8");
ASSERT_TRUE(vp8);
std::vector<webrtc::RtpCodecCapability> not_vp8_codecs =
std::vector<RtpCodecCapability> not_vp8_codecs =
local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO)
.codecs;
@ -1559,8 +1543,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection();
webrtc::RtpParameters parameters =
video_transceiver->sender()->GetParameters();
RtpParameters parameters = video_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = vp8;
RTCError error = video_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1572,12 +1555,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
absl::optional<webrtc::RtpCodecCapability> vp8 =
absl::optional<RtpCodecCapability> vp8 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp8");
ASSERT_TRUE(vp8);
std::vector<webrtc::RtpCodecCapability> not_vp8_codecs =
std::vector<RtpCodecCapability> not_vp8_codecs =
local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO)
.codecs;
@ -1622,8 +1605,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection();
webrtc::RtpParameters parameters =
video_transceiver->sender()->GetParameters();
RtpParameters parameters = video_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = vp8;
RTCError error = video_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1635,12 +1617,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
absl::optional<webrtc::RtpCodecCapability> opus =
absl::optional<RtpCodecCapability> opus =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"opus");
ASSERT_TRUE(opus);
std::vector<webrtc::RtpCodecCapability> not_opus_codecs =
std::vector<RtpCodecCapability> not_opus_codecs =
local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
.codecs;
@ -1651,9 +1633,9 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
}),
not_opus_codecs.end());
webrtc::RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
init.direction = RtpTransceiverDirection::kSendOnly;
RtpEncodingParameters encoding_parameters;
encoding_parameters.codec = opus;
init.send_encodings.push_back(encoding_parameters);
@ -1667,8 +1649,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection();
webrtc::RtpParameters parameters =
audio_transceiver->sender()->GetParameters();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
EXPECT_EQ(parameters.encodings[0].codec, opus);
ASSERT_TRUE(audio_transceiver->SetCodecPreferences(not_opus_codecs).ok());
@ -1684,24 +1665,24 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<webrtc::RtpCodecCapability> send_codecs =
std::vector<RtpCodecCapability> send_codecs =
local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
.codecs;
absl::optional<webrtc::RtpCodecCapability> opus =
absl::optional<RtpCodecCapability> opus =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"opus");
ASSERT_TRUE(opus);
absl::optional<webrtc::RtpCodecCapability> red =
absl::optional<RtpCodecCapability> red =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"red");
ASSERT_TRUE(red);
webrtc::RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
init.direction = RtpTransceiverDirection::kSendOnly;
RtpEncodingParameters encoding_parameters;
encoding_parameters.codec = opus;
init.send_encodings.push_back(encoding_parameters);
@ -1720,8 +1701,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection();
webrtc::RtpParameters parameters =
audio_transceiver->sender()->GetParameters();
RtpParameters parameters = audio_transceiver->sender()->GetParameters();
EXPECT_EQ(parameters.encodings[0].codec, opus);
EXPECT_EQ(parameters.codecs[0].payload_type, red->preferred_payload_type);
EXPECT_EQ(parameters.codecs[0].name, red->name);
@ -1743,14 +1723,14 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsScalabilityModeForSelectedCodec) {
rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
absl::optional<webrtc::RtpCodecCapability> vp8 =
absl::optional<RtpCodecCapability> vp8 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp8");
ASSERT_TRUE(vp8);
webrtc::RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
init.direction = RtpTransceiverDirection::kSendOnly;
RtpEncodingParameters encoding_parameters;
encoding_parameters.codec = vp8;
encoding_parameters.scalability_mode = "L1T3";
init.send_encodings.push_back(encoding_parameters);
@ -1761,8 +1741,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters =
video_transceiver->sender()->GetParameters();
RtpParameters parameters = video_transceiver->sender()->GetParameters();
parameters.encodings[0].scalability_mode = "L3T3";
RTCError error = video_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1774,12 +1753,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
absl::optional<webrtc::RtpCodecCapability> vp8 =
absl::optional<RtpCodecCapability> vp8 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp8");
ASSERT_TRUE(vp8);
std::vector<webrtc::RtpCodecCapability> not_vp8_codecs =
std::vector<RtpCodecCapability> not_vp8_codecs =
local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO)
.codecs;
@ -1790,9 +1769,9 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
}),
not_vp8_codecs.end());
webrtc::RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
init.direction = RtpTransceiverDirection::kSendOnly;
RtpEncodingParameters encoding_parameters;
encoding_parameters.rid = "h";
encoding_parameters.codec = vp8;
encoding_parameters.scale_resolution_down_by = 2;
@ -1811,8 +1790,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection();
webrtc::RtpParameters parameters =
video_transceiver->sender()->GetParameters();
RtpParameters parameters = video_transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 2u);
EXPECT_EQ(parameters.encodings[0].codec, vp8);
EXPECT_EQ(parameters.encodings[1].codec, vp8);
@ -1833,17 +1811,17 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
absl::optional<webrtc::RtpCodecCapability> vp8 =
absl::optional<RtpCodecCapability> vp8 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp8");
ASSERT_TRUE(vp8);
absl::optional<webrtc::RtpCodecCapability> vp9 =
absl::optional<RtpCodecCapability> vp9 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp9");
webrtc::RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
init.direction = RtpTransceiverDirection::kSendOnly;
RtpEncodingParameters encoding_parameters;
encoding_parameters.rid = "h";
encoding_parameters.codec = vp8;
encoding_parameters.scale_resolution_down_by = 2;

4
pc/peer_connection_factory_proxy.h
View File

@ -29,10 +29,10 @@ PROXY_METHOD2(RTCErrorOr<rtc::scoped_refptr<PeerConnectionInterface>>,
CreatePeerConnectionOrError,
const PeerConnectionInterface::RTCConfiguration&,
PeerConnectionDependencies)
PROXY_CONSTMETHOD1(webrtc::RtpCapabilities,
PROXY_CONSTMETHOD1(RtpCapabilities,
GetRtpSenderCapabilities,
cricket::MediaType)
PROXY_CONSTMETHOD1(webrtc::RtpCapabilities,
PROXY_CONSTMETHOD1(RtpCapabilities,
GetRtpReceiverCapabilities,
cricket::MediaType)
PROXY_METHOD1(rtc::scoped_refptr<MediaStreamInterface>,

189
pc/peer_connection_factory_unittest.cc
View File

@ -106,8 +106,7 @@ class NullPeerConnectionObserver : public PeerConnectionObserver {
PeerConnectionInterface::IceConnectionState new_state) override {}
void OnIceGatheringChange(
PeerConnectionInterface::IceGatheringState new_state) override {}
void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override {
}
void OnIceCandidate(const IceCandidateInterface* candidate) override {}
};
class MockNetworkManager : public rtc::NetworkManager {
@ -133,17 +132,15 @@ class PeerConnectionFactoryTest : public ::testing::Test {
private:
void SetUp() {
#ifdef WEBRTC_ANDROID
webrtc::InitializeAndroidObjects();
InitializeAndroidObjects();
#endif
// Use fake audio device module since we're only testing the interface
// level, and using a real one could make tests flaky e.g. when run in
// parallel.
factory_ = webrtc::CreatePeerConnectionFactory(
factory_ = CreatePeerConnectionFactory(
rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
rtc::scoped_refptr<webrtc::AudioDeviceModule>(
FakeAudioCaptureModule::Create()),
webrtc::CreateBuiltinAudioEncoderFactory(),
webrtc::CreateBuiltinAudioDecoderFactory(),
rtc::scoped_refptr<AudioDeviceModule>(FakeAudioCaptureModule::Create()),
CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
std::make_unique<VideoEncoderFactoryTemplate<
LibvpxVp8EncoderTemplateAdapter, LibvpxVp9EncoderTemplateAdapter,
OpenH264EncoderTemplateAdapter, LibaomAv1EncoderTemplateAdapter>>(),
@ -182,64 +179,64 @@ class PeerConnectionFactoryTest : public ::testing::Test {
}
}
void VerifyAudioCodecCapability(const webrtc::RtpCodecCapability& codec) {
void VerifyAudioCodecCapability(const RtpCodecCapability& codec) {
EXPECT_EQ(codec.kind, cricket::MEDIA_TYPE_AUDIO);
EXPECT_FALSE(codec.name.empty());
EXPECT_GT(codec.clock_rate, 0);
EXPECT_GT(codec.num_channels, 0);
}
void VerifyVideoCodecCapability(const webrtc::RtpCodecCapability& codec,
void VerifyVideoCodecCapability(const RtpCodecCapability& codec,
bool sender) {
EXPECT_EQ(codec.kind, cricket::MEDIA_TYPE_VIDEO);
EXPECT_FALSE(codec.name.empty());
EXPECT_GT(codec.clock_rate, 0);
if (sender) {
if (codec.name == "VP8" || codec.name == "H264") {
EXPECT_THAT(codec.scalability_modes,
UnorderedElementsAre(webrtc::ScalabilityMode::kL1T1,
webrtc::ScalabilityMode::kL1T2,
webrtc::ScalabilityMode::kL1T3))
EXPECT_THAT(
codec.scalability_modes,
UnorderedElementsAre(ScalabilityMode::kL1T1, ScalabilityMode::kL1T2,
ScalabilityMode::kL1T3))
<< "Codec: " << codec.name;
} else if (codec.name == "VP9" || codec.name == "AV1") {
EXPECT_THAT(
codec.scalability_modes,
UnorderedElementsAre(
// clang-format off
webrtc::ScalabilityMode::kL1T1,
webrtc::ScalabilityMode::kL1T2,
webrtc::ScalabilityMode::kL1T3,
webrtc::ScalabilityMode::kL2T1,
webrtc::ScalabilityMode::kL2T1h,
webrtc::ScalabilityMode::kL2T1_KEY,
webrtc::ScalabilityMode::kL2T2,
webrtc::ScalabilityMode::kL2T2h,
webrtc::ScalabilityMode::kL2T2_KEY,
webrtc::ScalabilityMode::kL2T2_KEY_SHIFT,
webrtc::ScalabilityMode::kL2T3,
webrtc::ScalabilityMode::kL2T3h,
webrtc::ScalabilityMode::kL2T3_KEY,
webrtc::ScalabilityMode::kL3T1,
webrtc::ScalabilityMode::kL3T1h,
webrtc::ScalabilityMode::kL3T1_KEY,
webrtc::ScalabilityMode::kL3T2,
webrtc::ScalabilityMode::kL3T2h,
webrtc::ScalabilityMode::kL3T2_KEY,
webrtc::ScalabilityMode::kL3T3,
webrtc::ScalabilityMode::kL3T3h,
webrtc::ScalabilityMode::kL3T3_KEY,
webrtc::ScalabilityMode::kS2T1,
webrtc::ScalabilityMode::kS2T1h,
webrtc::ScalabilityMode::kS2T2,
webrtc::ScalabilityMode::kS2T2h,
webrtc::ScalabilityMode::kS2T3,
webrtc::ScalabilityMode::kS2T3h,
webrtc::ScalabilityMode::kS3T1,
webrtc::ScalabilityMode::kS3T1h,
webrtc::ScalabilityMode::kS3T2,
webrtc::ScalabilityMode::kS3T2h,
webrtc::ScalabilityMode::kS3T3,
webrtc::ScalabilityMode::kS3T3h)
ScalabilityMode::kL1T1,
ScalabilityMode::kL1T2,
ScalabilityMode::kL1T3,
ScalabilityMode::kL2T1,
ScalabilityMode::kL2T1h,
ScalabilityMode::kL2T1_KEY,
ScalabilityMode::kL2T2,
ScalabilityMode::kL2T2h,
ScalabilityMode::kL2T2_KEY,
ScalabilityMode::kL2T2_KEY_SHIFT,
ScalabilityMode::kL2T3,
ScalabilityMode::kL2T3h,
ScalabilityMode::kL2T3_KEY,
ScalabilityMode::kL3T1,
ScalabilityMode::kL3T1h,
ScalabilityMode::kL3T1_KEY,
ScalabilityMode::kL3T2,
ScalabilityMode::kL3T2h,
ScalabilityMode::kL3T2_KEY,
ScalabilityMode::kL3T3,
ScalabilityMode::kL3T3h,
ScalabilityMode::kL3T3_KEY,
ScalabilityMode::kS2T1,
ScalabilityMode::kS2T1h,
ScalabilityMode::kS2T2,
ScalabilityMode::kS2T2h,
ScalabilityMode::kS2T3,
ScalabilityMode::kS2T3h,
ScalabilityMode::kS3T1,
ScalabilityMode::kS3T1h,
ScalabilityMode::kS3T2,
ScalabilityMode::kS3T2h,
ScalabilityMode::kS3T3,
ScalabilityMode::kS3T3h)
// clang-format on
)
<< "Codec: " << codec.name;
@ -251,7 +248,7 @@ class PeerConnectionFactoryTest : public ::testing::Test {
}
}
webrtc::test::ScopedKeyValueConfig field_trials_;
test::ScopedKeyValueConfig field_trials_;
std::unique_ptr<rtc::SocketServer> socket_server_;
rtc::AutoSocketServerThread main_thread_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> factory_;
@ -267,7 +264,7 @@ class PeerConnectionFactoryTest : public ::testing::Test {
// to reconstruct factory with our own ConnectionContext.
rtc::scoped_refptr<PeerConnectionFactoryInterface>
CreatePeerConnectionFactoryWithRtxDisabled() {
webrtc::PeerConnectionFactoryDependencies pcf_dependencies;
PeerConnectionFactoryDependencies pcf_dependencies;
pcf_dependencies.signaling_thread = rtc::Thread::Current();
pcf_dependencies.worker_thread = rtc::Thread::Current();
pcf_dependencies.network_thread = rtc::Thread::Current();
@ -287,7 +284,7 @@ CreatePeerConnectionFactoryWithRtxDisabled() {
OpenH264DecoderTemplateAdapter, Dav1dDecoderTemplateAdapter>>(),
EnableMedia(pcf_dependencies);
rtc::scoped_refptr<webrtc::ConnectionContext> context =
rtc::scoped_refptr<ConnectionContext> context =
ConnectionContext::Create(&pcf_dependencies);
context->set_use_rtx(false);
return rtc::make_ref_counted<PeerConnectionFactory>(context,
@ -302,26 +299,26 @@ CreatePeerConnectionFactoryWithRtxDisabled() {
// See https://bugs.chromium.org/p/webrtc/issues/detail?id=7806 for details.
TEST(PeerConnectionFactoryTestInternal, DISABLED_CreatePCUsingInternalModules) {
#ifdef WEBRTC_ANDROID
webrtc::InitializeAndroidObjects();
InitializeAndroidObjects();
#endif
rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
webrtc::CreatePeerConnectionFactory(
CreatePeerConnectionFactory(
nullptr /* network_thread */, nullptr /* worker_thread */,
nullptr /* signaling_thread */, nullptr /* default_adm */,
webrtc::CreateBuiltinAudioEncoderFactory(),
webrtc::CreateBuiltinAudioDecoderFactory(),
CreateBuiltinAudioEncoderFactory(),
CreateBuiltinAudioDecoderFactory(),
nullptr /* video_encoder_factory */,
nullptr /* video_decoder_factory */, nullptr /* audio_mixer */,
nullptr /* audio_processing */));
NullPeerConnectionObserver observer;
webrtc::PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = SdpSemantics::kUnifiedPlan;
std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
new FakeRTCCertificateGenerator());
webrtc::PeerConnectionDependencies pc_dependencies(&observer);
PeerConnectionDependencies pc_dependencies(&observer);
pc_dependencies.cert_generator = std::move(cert_generator);
auto result =
factory->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
@ -330,7 +327,7 @@ TEST(PeerConnectionFactoryTestInternal, DISABLED_CreatePCUsingInternalModules) {
}
TEST_F(PeerConnectionFactoryTest, CheckRtpSenderAudioCapabilities) {
webrtc::RtpCapabilities audio_capabilities =
RtpCapabilities audio_capabilities =
factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO);
EXPECT_FALSE(audio_capabilities.codecs.empty());
for (const auto& codec : audio_capabilities.codecs) {
@ -343,7 +340,7 @@ TEST_F(PeerConnectionFactoryTest, CheckRtpSenderAudioCapabilities) {
}
TEST_F(PeerConnectionFactoryTest, CheckRtpSenderVideoCapabilities) {
webrtc::RtpCapabilities video_capabilities =
RtpCapabilities video_capabilities =
factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO);
EXPECT_FALSE(video_capabilities.codecs.empty());
for (const auto& codec : video_capabilities.codecs) {
@ -356,7 +353,7 @@ TEST_F(PeerConnectionFactoryTest, CheckRtpSenderVideoCapabilities) {
}
TEST_F(PeerConnectionFactoryTest, CheckRtpSenderRtxEnabledCapabilities) {
webrtc::RtpCapabilities video_capabilities =
RtpCapabilities video_capabilities =
factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO);
const auto it = std::find_if(
video_capabilities.codecs.begin(), video_capabilities.codecs.end(),
@ -366,7 +363,7 @@ TEST_F(PeerConnectionFactoryTest, CheckRtpSenderRtxEnabledCapabilities) {
TEST(PeerConnectionFactoryTestInternal, CheckRtpSenderRtxDisabledCapabilities) {
auto factory = CreatePeerConnectionFactoryWithRtxDisabled();
webrtc::RtpCapabilities video_capabilities =
RtpCapabilities video_capabilities =
factory->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO);
const auto it = std::find_if(
video_capabilities.codecs.begin(), video_capabilities.codecs.end(),
@ -375,14 +372,14 @@ TEST(PeerConnectionFactoryTestInternal, CheckRtpSenderRtxDisabledCapabilities) {
}
TEST_F(PeerConnectionFactoryTest, CheckRtpSenderDataCapabilities) {
webrtc::RtpCapabilities data_capabilities =
RtpCapabilities data_capabilities =
factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_DATA);
EXPECT_TRUE(data_capabilities.codecs.empty());
EXPECT_TRUE(data_capabilities.header_extensions.empty());
}
TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverAudioCapabilities) {
webrtc::RtpCapabilities audio_capabilities =
RtpCapabilities audio_capabilities =
factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_AUDIO);
EXPECT_FALSE(audio_capabilities.codecs.empty());
for (const auto& codec : audio_capabilities.codecs) {
@ -395,7 +392,7 @@ TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverAudioCapabilities) {
}
TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverVideoCapabilities) {
webrtc::RtpCapabilities video_capabilities =
RtpCapabilities video_capabilities =
factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_VIDEO);
EXPECT_FALSE(video_capabilities.codecs.empty());
for (const auto& codec : video_capabilities.codecs) {
@ -408,7 +405,7 @@ TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverVideoCapabilities) {
}
TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverRtxEnabledCapabilities) {
webrtc::RtpCapabilities video_capabilities =
RtpCapabilities video_capabilities =
factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_VIDEO);
const auto it = std::find_if(
video_capabilities.codecs.begin(), video_capabilities.codecs.end(),
@ -419,7 +416,7 @@ TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverRtxEnabledCapabilities) {
TEST(PeerConnectionFactoryTestInternal,
CheckRtpReceiverRtxDisabledCapabilities) {
auto factory = CreatePeerConnectionFactoryWithRtxDisabled();
webrtc::RtpCapabilities video_capabilities =
RtpCapabilities video_capabilities =
factory->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_VIDEO);
const auto it = std::find_if(
video_capabilities.codecs.begin(), video_capabilities.codecs.end(),
@ -428,7 +425,7 @@ TEST(PeerConnectionFactoryTestInternal,
}
TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverDataCapabilities) {
webrtc::RtpCapabilities data_capabilities =
RtpCapabilities data_capabilities =
factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_DATA);
EXPECT_TRUE(data_capabilities.codecs.empty());
EXPECT_TRUE(data_capabilities.header_extensions.empty());
@ -438,8 +435,8 @@ TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverDataCapabilities) {
// configuration. Also verifies the URL's parsed correctly as expected.
TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServers) {
PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
webrtc::PeerConnectionInterface::IceServer ice_server;
config.sdp_semantics = SdpSemantics::kUnifiedPlan;
PeerConnectionInterface::IceServer ice_server;
ice_server.uri = kStunIceServer;
config.servers.push_back(ice_server);
ice_server.uri = kTurnIceServer;
@ -450,7 +447,7 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServers) {
ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword;
config.servers.push_back(ice_server);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_);
@ -475,15 +472,15 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServers) {
// configuration. Also verifies the list of URL's parsed correctly as expected.
TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServersUrls) {
PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
webrtc::PeerConnectionInterface::IceServer ice_server;
config.sdp_semantics = SdpSemantics::kUnifiedPlan;
PeerConnectionInterface::IceServer ice_server;
ice_server.urls.push_back(kStunIceServer);
ice_server.urls.push_back(kTurnIceServer);
ice_server.urls.push_back(kTurnIceServerWithTransport);
ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword;
config.servers.push_back(ice_server);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_);
@ -506,15 +503,15 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServersUrls) {
TEST_F(PeerConnectionFactoryTest, CreatePCUsingNoUsernameInUri) {
PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
webrtc::PeerConnectionInterface::IceServer ice_server;
config.sdp_semantics = SdpSemantics::kUnifiedPlan;
PeerConnectionInterface::IceServer ice_server;
ice_server.uri = kStunIceServer;
config.servers.push_back(ice_server);
ice_server.uri = kTurnIceServerWithNoUsernameInUri;
ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword;
config.servers.push_back(ice_server);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_);
@ -532,13 +529,13 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingNoUsernameInUri) {
// has transport parameter in it.
TEST_F(PeerConnectionFactoryTest, CreatePCUsingTurnUrlWithTransportParam) {
PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
webrtc::PeerConnectionInterface::IceServer ice_server;
config.sdp_semantics = SdpSemantics::kUnifiedPlan;
PeerConnectionInterface::IceServer ice_server;
ice_server.uri = kTurnIceServerWithTransport;
ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword;
config.servers.push_back(ice_server);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_);
@ -554,8 +551,8 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingTurnUrlWithTransportParam) {
TEST_F(PeerConnectionFactoryTest, CreatePCUsingSecureTurnUrl) {
PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
webrtc::PeerConnectionInterface::IceServer ice_server;
config.sdp_semantics = SdpSemantics::kUnifiedPlan;
PeerConnectionInterface::IceServer ice_server;
ice_server.uri = kSecureTurnIceServer;
ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword;
@ -568,7 +565,7 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingSecureTurnUrl) {
ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword;
config.servers.push_back(ice_server);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_);
@ -593,8 +590,8 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingSecureTurnUrl) {
TEST_F(PeerConnectionFactoryTest, CreatePCUsingIPLiteralAddress) {
PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
webrtc::PeerConnectionInterface::IceServer ice_server;
config.sdp_semantics = SdpSemantics::kUnifiedPlan;
PeerConnectionInterface::IceServer ice_server;
ice_server.uri = kStunIceServerWithIPv4Address;
config.servers.push_back(ice_server);
ice_server.uri = kStunIceServerWithIPv4AddressWithoutPort;
@ -607,7 +604,7 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIPLiteralAddress) {
ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword;
config.servers.push_back(ice_server);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_);
@ -635,8 +632,8 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIPLiteralAddress) {
// This test verifies the captured stream is rendered locally using a
// local video track.
TEST_F(PeerConnectionFactoryTest, LocalRendering) {
rtc::scoped_refptr<webrtc::FakeVideoTrackSource> source =
webrtc::FakeVideoTrackSource::Create(/*is_screencast=*/false);
rtc::scoped_refptr<FakeVideoTrackSource> source =
FakeVideoTrackSource::Create(/*is_screencast=*/false);
cricket::FakeFrameSource frame_source(1280, 720,
rtc::kNumMicrosecsPerSec / 30);
@ -664,7 +661,7 @@ TEST_F(PeerConnectionFactoryTest, LocalRendering) {
}
TEST(PeerConnectionFactoryDependenciesTest, UsesNetworkManager) {
constexpr webrtc::TimeDelta kWaitTimeout = webrtc::TimeDelta::Seconds(10);
constexpr TimeDelta kWaitTimeout = TimeDelta::Seconds(10);
auto mock_network_manager = std::make_unique<NiceMock<MockNetworkManager>>();
rtc::Event called;
@ -672,24 +669,24 @@ TEST(PeerConnectionFactoryDependenciesTest, UsesNetworkManager) {
.Times(AtLeast(1))
.WillRepeatedly(InvokeWithoutArgs([&] { called.Set(); }));
webrtc::PeerConnectionFactoryDependencies pcf_dependencies;
PeerConnectionFactoryDependencies pcf_dependencies;
pcf_dependencies.network_manager = std::move(mock_network_manager);
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pcf =
rtc::scoped_refptr<PeerConnectionFactoryInterface> pcf =
CreateModularPeerConnectionFactory(std::move(pcf_dependencies));
PeerConnectionInterface::RTCConfiguration config;
config.ice_candidate_pool_size = 2;
NullPeerConnectionObserver observer;
auto pc = pcf->CreatePeerConnectionOrError(
config, webrtc::PeerConnectionDependencies(&observer));
config, PeerConnectionDependencies(&observer));
ASSERT_TRUE(pc.ok());
called.Wait(kWaitTimeout);
}
TEST(PeerConnectionFactoryDependenciesTest, UsesPacketSocketFactory) {
constexpr webrtc::TimeDelta kWaitTimeout = webrtc::TimeDelta::Seconds(10);
constexpr TimeDelta kWaitTimeout = TimeDelta::Seconds(10);
auto mock_socket_factory =
std::make_unique<NiceMock<rtc::MockPacketSocketFactory>>();
@ -701,10 +698,10 @@ TEST(PeerConnectionFactoryDependenciesTest, UsesPacketSocketFactory) {
}))
.WillRepeatedly(Return(nullptr));
webrtc::PeerConnectionFactoryDependencies pcf_dependencies;
PeerConnectionFactoryDependencies pcf_dependencies;
pcf_dependencies.packet_socket_factory = std::move(mock_socket_factory);
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pcf =
rtc::scoped_refptr<PeerConnectionFactoryInterface> pcf =
CreateModularPeerConnectionFactory(std::move(pcf_dependencies));
// By default, localhost addresses are ignored, which makes tests fail if test
@ -717,7 +714,7 @@ TEST(PeerConnectionFactoryDependenciesTest, UsesPacketSocketFactory) {
config.ice_candidate_pool_size = 2;
NullPeerConnectionObserver observer;
auto pc = pcf->CreatePeerConnectionOrError(
config, webrtc::PeerConnectionDependencies(&observer));
config, PeerConnectionDependencies(&observer));
ASSERT_TRUE(pc.ok());
called.Wait(kWaitTimeout);

12
pc/peer_connection_field_trial_tests.cc
View File

@ -68,7 +68,7 @@ class PeerConnectionFieldTrialTest : public ::testing::Test {
#ifdef WEBRTC_ANDROID
InitializeAndroidObjects();
#endif
webrtc::PeerConnectionInterface::IceServer ice_server;
PeerConnectionInterface::IceServer ice_server;
ice_server.uri = "stun:stun.l.google.com:19302";
config_.servers.push_back(ice_server);
config_.sdp_semantics = SdpSemantics::kUnifiedPlan;
@ -108,7 +108,7 @@ class PeerConnectionFieldTrialTest : public ::testing::Test {
std::unique_ptr<rtc::SocketServer> socket_server_;
rtc::AutoSocketServerThread main_thread_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_ = nullptr;
webrtc::PeerConnectionInterface::RTCConfiguration config_;
PeerConnectionInterface::RTCConfiguration config_;
};
// Tests for the dependency descriptor field trial. The dependency descriptor
@ -133,7 +133,7 @@ TEST_F(PeerConnectionFieldTrialTest, EnableDependencyDescriptorAdvertised) {
media_description1->rtp_header_extensions();
bool found = absl::c_find_if(rtp_header_extensions1,
[](const webrtc::RtpExtension& rtp_extension) {
[](const RtpExtension& rtp_extension) {
return rtp_extension.uri ==
RtpExtension::kDependencyDescriptorUri;
}) != rtp_header_extensions1.end();
@ -163,14 +163,14 @@ TEST_F(PeerConnectionFieldTrialTest, InjectDependencyDescriptor) {
media_description1->rtp_header_extensions();
bool found1 = absl::c_find_if(rtp_header_extensions1,
[](const webrtc::RtpExtension& rtp_extension) {
[](const RtpExtension& rtp_extension) {
return rtp_extension.uri ==
RtpExtension::kDependencyDescriptorUri;
}) != rtp_header_extensions1.end();
EXPECT_FALSE(found1);
std::set<int> existing_ids;
for (const webrtc::RtpExtension& rtp_extension : rtp_header_extensions1) {
for (const RtpExtension& rtp_extension : rtp_header_extensions1) {
existing_ids.insert(rtp_extension.id);
}
@ -207,7 +207,7 @@ TEST_F(PeerConnectionFieldTrialTest, InjectDependencyDescriptor) {
media_description2->rtp_header_extensions();
bool found2 = absl::c_find_if(rtp_header_extensions2,
[](const webrtc::RtpExtension& rtp_extension) {
[](const RtpExtension& rtp_extension) {
return rtp_extension.uri ==
RtpExtension::kDependencyDescriptorUri;
}) != rtp_header_extensions2.end();

2
pc/peer_connection_header_extension_unittest.cc
View File

@ -114,7 +114,7 @@ class PeerConnectionHeaderExtensionTest
pc_factory, result.MoveValue(), std::move(observer));
}
webrtc::test::ScopedKeyValueConfig field_trials_;
test::ScopedKeyValueConfig field_trials_;
std::unique_ptr<rtc::SocketServer> socket_server_;
rtc::AutoSocketServerThread main_thread_;
std::vector<RtpHeaderExtensionCapability> extensions_;

120
pc/peer_connection_histogram_unittest.cc
View File

@ -94,7 +94,7 @@ typedef PeerConnectionWrapperForUsageHistogramTest* RawWrapperPtr;
class ObserverForUsageHistogramTest : public MockPeerConnectionObserver {
public:
void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override;
void OnIceCandidate(const IceCandidateInterface* candidate) override;
void OnInterestingUsage(int usage_pattern) override {
interesting_usage_detected_ = usage_pattern;
@ -157,12 +157,11 @@ class PeerConnectionWrapperForUsageHistogramTest
return static_cast<ObserverForUsageHistogramTest*>(observer())
->HaveDataChannel();
}
void BufferIceCandidate(const webrtc::IceCandidateInterface* candidate) {
void BufferIceCandidate(const IceCandidateInterface* candidate) {
std::string sdp;
EXPECT_TRUE(candidate->ToString(&sdp));
std::unique_ptr<webrtc::IceCandidateInterface> candidate_copy(
CreateIceCandidate(candidate->sdp_mid(), candidate->sdp_mline_index(),
sdp, nullptr));
std::unique_ptr<IceCandidateInterface> candidate_copy(CreateIceCandidate(
candidate->sdp_mid(), candidate->sdp_mline_index(), sdp, nullptr));
buffered_candidates_.push_back(std::move(candidate_copy));
}
@ -213,19 +212,18 @@ class PeerConnectionWrapperForUsageHistogramTest
return true;
}
webrtc::PeerConnectionInterface::IceGatheringState ice_gathering_state() {
PeerConnectionInterface::IceGatheringState ice_gathering_state() {
return pc()->ice_gathering_state();
}
private:
// Candidates that have been sent but not yet configured
std::vector<std::unique_ptr<webrtc::IceCandidateInterface>>
buffered_candidates_;
std::vector<std::unique_ptr<IceCandidateInterface>> buffered_candidates_;
};
// Buffers candidates until we add them via AddBufferedIceCandidates.
void ObserverForUsageHistogramTest::OnIceCandidate(
const webrtc::IceCandidateInterface* candidate) {
const IceCandidateInterface* candidate) {
// If target is not set, ignore. This happens in one-ended unit tests.
if (candidate_target_) {
this->candidate_target_->BufferIceCandidate(candidate);
@ -242,12 +240,12 @@ class PeerConnectionUsageHistogramTest : public ::testing::Test {
: vss_(new rtc::VirtualSocketServer()),
socket_factory_(new rtc::BasicPacketSocketFactory(vss_.get())),
main_(vss_.get()) {
webrtc::metrics::Reset();
metrics::Reset();
}
WrapperPtr CreatePeerConnection() {
RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
config.sdp_semantics = SdpSemantics::kUnifiedPlan;
return CreatePeerConnection(
config, PeerConnectionFactoryInterface::Options(), nullptr);
}
@ -259,13 +257,13 @@ class PeerConnectionUsageHistogramTest : public ::testing::Test {
WrapperPtr CreatePeerConnectionWithMdns(const RTCConfiguration& config) {
auto resolver_factory =
std::make_unique<NiceMock<webrtc::MockAsyncDnsResolverFactory>>();
std::make_unique<NiceMock<MockAsyncDnsResolverFactory>>();
webrtc::PeerConnectionDependencies deps(nullptr /* observer_in */);
PeerConnectionDependencies deps(nullptr /* observer_in */);
auto fake_network = NewFakeNetwork();
fake_network->set_mdns_responder(
std::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
std::make_unique<FakeMdnsResponder>(rtc::Thread::Current()));
fake_network->AddInterface(NextLocalAddress());
std::unique_ptr<cricket::BasicPortAllocator> port_allocator(
@ -280,7 +278,7 @@ class PeerConnectionUsageHistogramTest : public ::testing::Test {
WrapperPtr CreatePeerConnectionWithImmediateReport() {
RTCConfiguration configuration;
configuration.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
configuration.sdp_semantics = SdpSemantics::kUnifiedPlan;
configuration.report_usage_pattern_delay_ms = 0;
return CreatePeerConnection(
configuration, PeerConnectionFactoryInterface::Options(), nullptr);
@ -361,7 +359,7 @@ class PeerConnectionUsageHistogramTest : public ::testing::Test {
// This works correctly only if there is only one sample value
// that has been counted.
// Returns -1 for "not found".
return webrtc::metrics::MinSample(kUsagePatternMetric);
return metrics::MinSample(kUsagePatternMetric);
}
// The PeerConnection's port allocator is tied to the PeerConnection's
@ -390,10 +388,10 @@ TEST_F(PeerConnectionUsageHistogramTest, UsageFingerprintHistogramFromTimeout) {
auto pc = CreatePeerConnectionWithImmediateReport();
int expected_fingerprint = MakeUsageFingerprint({});
EXPECT_METRIC_EQ_WAIT(1, webrtc::metrics::NumSamples(kUsagePatternMetric),
EXPECT_METRIC_EQ_WAIT(1, metrics::NumSamples(kUsagePatternMetric),
kDefaultTimeout);
EXPECT_METRIC_EQ(
1, webrtc::metrics::NumEvents(kUsagePatternMetric, expected_fingerprint));
1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint));
}
#ifndef WEBRTC_ANDROID
@ -418,11 +416,10 @@ TEST_F(PeerConnectionUsageHistogramTest, FingerprintAudioVideo) {
UsageEvent::DIRECT_CONNECTION_SELECTED, UsageEvent::CLOSE_CALLED});
// In this case, we may or may not have PRIVATE_CANDIDATE_COLLECTED,
// depending on the machine configuration.
EXPECT_METRIC_EQ(2, webrtc::metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(2, metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_TRUE(
webrtc::metrics::NumEvents(kUsagePatternMetric, expected_fingerprint) ==
2 ||
webrtc::metrics::NumEvents(
metrics::NumEvents(kUsagePatternMetric, expected_fingerprint) == 2 ||
metrics::NumEvents(
kUsagePatternMetric,
expected_fingerprint |
static_cast<int>(UsageEvent::PRIVATE_CANDIDATE_COLLECTED)) == 2);
@ -463,11 +460,11 @@ TEST_F(PeerConnectionUsageHistogramTest, FingerprintWithMdnsCaller) {
UsageEvent::CANDIDATE_COLLECTED, UsageEvent::ADD_ICE_CANDIDATE_SUCCEEDED,
UsageEvent::REMOTE_MDNS_CANDIDATE_ADDED, UsageEvent::ICE_STATE_CONNECTED,
UsageEvent::REMOTE_CANDIDATE_ADDED, UsageEvent::CLOSE_CALLED});
EXPECT_METRIC_EQ(2, webrtc::metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
expected_fingerprint_caller));
EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
expected_fingerprint_callee));
EXPECT_METRIC_EQ(2, metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(
1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_caller));
EXPECT_METRIC_EQ(
1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_callee));
}
// Test getting the usage fingerprint when the callee collects an mDNS
@ -504,11 +501,11 @@ TEST_F(PeerConnectionUsageHistogramTest, FingerprintWithMdnsCallee) {
UsageEvent::ADD_ICE_CANDIDATE_SUCCEEDED, UsageEvent::ICE_STATE_CONNECTED,
UsageEvent::REMOTE_CANDIDATE_ADDED,
UsageEvent::DIRECT_CONNECTION_SELECTED, UsageEvent::CLOSE_CALLED});
EXPECT_METRIC_EQ(2, webrtc::metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
expected_fingerprint_caller));
EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
expected_fingerprint_callee));
EXPECT_METRIC_EQ(2, metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(
1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_caller));
EXPECT_METRIC_EQ(
1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_callee));
}
#ifdef WEBRTC_HAVE_SCTP
@ -526,11 +523,10 @@ TEST_F(PeerConnectionUsageHistogramTest, FingerprintDataOnly) {
UsageEvent::CANDIDATE_COLLECTED, UsageEvent::ADD_ICE_CANDIDATE_SUCCEEDED,
UsageEvent::ICE_STATE_CONNECTED, UsageEvent::REMOTE_CANDIDATE_ADDED,
UsageEvent::DIRECT_CONNECTION_SELECTED, UsageEvent::CLOSE_CALLED});
EXPECT_METRIC_EQ(2, webrtc::metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(2, metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_TRUE(
webrtc::metrics::NumEvents(kUsagePatternMetric, expected_fingerprint) ==
2 ||
webrtc::metrics::NumEvents(
metrics::NumEvents(kUsagePatternMetric, expected_fingerprint) == 2 ||
metrics::NumEvents(
kUsagePatternMetric,
expected_fingerprint |
static_cast<int>(UsageEvent::PRIVATE_CANDIDATE_COLLECTED)) == 2);
@ -554,9 +550,9 @@ TEST_F(PeerConnectionUsageHistogramTest, FingerprintStunTurn) {
int expected_fingerprint = MakeUsageFingerprint(
{UsageEvent::STUN_SERVER_ADDED, UsageEvent::TURN_SERVER_ADDED,
UsageEvent::CLOSE_CALLED});
EXPECT_METRIC_EQ(1, webrtc::metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(1, metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(
1, webrtc::metrics::NumEvents(kUsagePatternMetric, expected_fingerprint));
1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint));
}
TEST_F(PeerConnectionUsageHistogramTest, FingerprintStunTurnInReconfiguration) {
@ -576,9 +572,9 @@ TEST_F(PeerConnectionUsageHistogramTest, FingerprintStunTurnInReconfiguration) {
int expected_fingerprint = MakeUsageFingerprint(
{UsageEvent::STUN_SERVER_ADDED, UsageEvent::TURN_SERVER_ADDED,
UsageEvent::CLOSE_CALLED});
EXPECT_METRIC_EQ(1, webrtc::metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(1, metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(
1, webrtc::metrics::NumEvents(kUsagePatternMetric, expected_fingerprint));
1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint));
}
TEST_F(PeerConnectionUsageHistogramTest, FingerprintWithPrivateIPCaller) {
@ -604,11 +600,11 @@ TEST_F(PeerConnectionUsageHistogramTest, FingerprintWithPrivateIPCaller) {
UsageEvent::REMOTE_PRIVATE_CANDIDATE_ADDED,
UsageEvent::ICE_STATE_CONNECTED, UsageEvent::REMOTE_CANDIDATE_ADDED,
UsageEvent::DIRECT_CONNECTION_SELECTED, UsageEvent::CLOSE_CALLED});
EXPECT_METRIC_EQ(2, webrtc::metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
expected_fingerprint_caller));
EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
expected_fingerprint_callee));
EXPECT_METRIC_EQ(2, metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(
1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_caller));
EXPECT_METRIC_EQ(
1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_callee));
}
TEST_F(PeerConnectionUsageHistogramTest, FingerprintWithPrivateIpv6Callee) {
@ -636,11 +632,11 @@ TEST_F(PeerConnectionUsageHistogramTest, FingerprintWithPrivateIpv6Callee) {
UsageEvent::ADD_ICE_CANDIDATE_SUCCEEDED,
UsageEvent::REMOTE_CANDIDATE_ADDED, UsageEvent::ICE_STATE_CONNECTED,
UsageEvent::DIRECT_CONNECTION_SELECTED, UsageEvent::CLOSE_CALLED});
EXPECT_METRIC_EQ(2, webrtc::metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
expected_fingerprint_caller));
EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
expected_fingerprint_callee));
EXPECT_METRIC_EQ(2, metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(
1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_caller));
EXPECT_METRIC_EQ(
1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_callee));
}
#ifndef WEBRTC_ANDROID
@ -664,7 +660,7 @@ TEST_F(PeerConnectionUsageHistogramTest,
ASSERT_TRUE(caller->SetLocalDescription(caller->CreateOffer()));
// Wait until the gathering completes so that the session description would
// have contained ICE candidates.
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceGatheringComplete,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringComplete,
caller->ice_gathering_state(), kDefaultTimeout);
EXPECT_TRUE(caller->observer()->candidate_gathered());
// Get the current offer that contains candidates and pass it to the callee.
@ -713,11 +709,11 @@ TEST_F(PeerConnectionUsageHistogramTest,
UsageEvent::REMOTE_PRIVATE_CANDIDATE_ADDED,
UsageEvent::REMOTE_IPV6_CANDIDATE_ADDED, UsageEvent::ICE_STATE_CONNECTED,
UsageEvent::DIRECT_CONNECTION_SELECTED, UsageEvent::CLOSE_CALLED});
EXPECT_METRIC_EQ(2, webrtc::metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
expected_fingerprint_caller));
EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
expected_fingerprint_callee));
EXPECT_METRIC_EQ(2, metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(
1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_caller));
EXPECT_METRIC_EQ(
1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_callee));
}
TEST_F(PeerConnectionUsageHistogramTest, NotableUsageNoted) {
@ -728,7 +724,7 @@ TEST_F(PeerConnectionUsageHistogramTest, NotableUsageNoted) {
int expected_fingerprint = MakeUsageFingerprint(
{UsageEvent::DATA_ADDED, UsageEvent::SET_LOCAL_DESCRIPTION_SUCCEEDED,
UsageEvent::CANDIDATE_COLLECTED, UsageEvent::CLOSE_CALLED});
EXPECT_METRIC_EQ(1, webrtc::metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(1, metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_TRUE(
expected_fingerprint == ObservedFingerprint() ||
(expected_fingerprint |
@ -745,9 +741,9 @@ TEST_F(PeerConnectionUsageHistogramTest, NotableUsageOnEventFiring) {
int expected_fingerprint = MakeUsageFingerprint(
{UsageEvent::DATA_ADDED, UsageEvent::SET_LOCAL_DESCRIPTION_SUCCEEDED,
UsageEvent::CANDIDATE_COLLECTED});
EXPECT_METRIC_EQ(0, webrtc::metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(0, metrics::NumSamples(kUsagePatternMetric));
caller->GetInternalPeerConnection()->RequestUsagePatternReportForTesting();
EXPECT_METRIC_EQ_WAIT(1, webrtc::metrics::NumSamples(kUsagePatternMetric),
EXPECT_METRIC_EQ_WAIT(1, metrics::NumSamples(kUsagePatternMetric),
kDefaultTimeout);
EXPECT_METRIC_TRUE(
expected_fingerprint == ObservedFingerprint() ||
@ -766,12 +762,12 @@ TEST_F(PeerConnectionUsageHistogramTest,
int expected_fingerprint = MakeUsageFingerprint(
{UsageEvent::DATA_ADDED, UsageEvent::SET_LOCAL_DESCRIPTION_SUCCEEDED,
UsageEvent::CANDIDATE_COLLECTED, UsageEvent::CLOSE_CALLED});
EXPECT_METRIC_EQ(0, webrtc::metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(0, metrics::NumSamples(kUsagePatternMetric));
caller->pc()->Close();
EXPECT_METRIC_EQ(1, webrtc::metrics::NumSamples(kUsagePatternMetric));
EXPECT_METRIC_EQ(1, metrics::NumSamples(kUsagePatternMetric));
caller->GetInternalPeerConnection()->RequestUsagePatternReportForTesting();
caller->observer()->ClearInterestingUsageDetector();
EXPECT_METRIC_EQ_WAIT(2, webrtc::metrics::NumSamples(kUsagePatternMetric),
EXPECT_METRIC_EQ_WAIT(2, metrics::NumSamples(kUsagePatternMetric),
kDefaultTimeout);
EXPECT_METRIC_TRUE(
expected_fingerprint == ObservedFingerprint() ||

6
pc/peer_connection_ice_unittest.cc
View File

@ -342,7 +342,7 @@ class PeerConnectionIceTest
public ::testing::WithParamInterface<SdpSemantics> {
protected:
PeerConnectionIceTest() : PeerConnectionIceBaseTest(GetParam()) {
webrtc::metrics::Reset();
metrics::Reset();
}
};
@ -514,7 +514,7 @@ TEST_P(PeerConnectionIceTest, CannotAddCandidateWhenRemoteDescriptionNotSet) {
EXPECT_FALSE(caller->pc()->AddIceCandidate(jsep_candidate.get()));
EXPECT_METRIC_THAT(
webrtc::metrics::Samples("WebRTC.PeerConnection.AddIceCandidate"),
metrics::Samples("WebRTC.PeerConnection.AddIceCandidate"),
ElementsAre(Pair(kAddIceCandidateFailNoRemoteDescription, 2)));
}
@ -1457,7 +1457,7 @@ class PeerConnectionIceConfigTest : public ::testing::Test {
pc_ = result.MoveValue();
}
webrtc::test::ScopedKeyValueConfig field_trials_;
test::ScopedKeyValueConfig field_trials_;
std::unique_ptr<rtc::SocketServer> socket_server_;
rtc::AutoSocketServerThread main_thread_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_ = nullptr;

274
pc/peer_connection_integrationtest.cc
View File

@ -124,7 +124,7 @@ class FakeClockForTest : public rtc::ScopedFakeClock {
// Some things use a time of "0" as a special value, so we need to start out
// the fake clock at a nonzero time.
// TODO(deadbeef): Fix this.
AdvanceTime(webrtc::TimeDelta::Seconds(1));
AdvanceTime(TimeDelta::Seconds(1));
}
// Explicit handle.
@ -324,7 +324,7 @@ TEST_P(PeerConnectionIntegrationTest,
ConnectFakeSignaling();
// Add video tracks with 16:9 aspect ratio, size 1280 x 720.
webrtc::FakePeriodicVideoSource::Config config;
FakePeriodicVideoSource::Config config;
config.width = 1280;
config.height = 720;
config.timestamp_offset_ms = rtc::TimeMillis();
@ -366,7 +366,7 @@ TEST_P(PeerConnectionIntegrationTest, EndToEndCallWithSendOnlyVideo) {
CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/true));
ConnectFakeSignaling();
// Add one-directional video, from caller to callee.
rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
rtc::scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack();
caller()->AddTrack(caller_track);
PeerConnectionInterface::RTCOfferAnswerOptions options;
@ -391,7 +391,7 @@ TEST_P(PeerConnectionIntegrationTest, EndToEndCallWithReceiveOnlyVideo) {
CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/false));
ConnectFakeSignaling();
// Add one-directional video, from callee to caller.
rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
rtc::scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack();
callee()->AddTrack(callee_track);
PeerConnectionInterface::RTCOfferAnswerOptions options;
@ -414,14 +414,14 @@ TEST_P(PeerConnectionIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
// Add one-directional video, from caller to callee.
rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
rtc::scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack();
caller()->AddTrack(caller_track);
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
// Add receive video.
rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
rtc::scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack();
callee()->AddTrack(callee_track);
caller()->CreateAndSetAndSignalOffer();
@ -438,14 +438,14 @@ TEST_P(PeerConnectionIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
// Add one-directional video, from callee to caller.
rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
rtc::scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack();
callee()->AddTrack(callee_track);
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
// Add send video.
rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
rtc::scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack();
caller()->AddTrack(caller_track);
caller()->CreateAndSetAndSignalOffer();
@ -462,15 +462,15 @@ TEST_P(PeerConnectionIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
// Add send video, from caller to callee.
rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
rtc::scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack();
rtc::scoped_refptr<webrtc::RtpSenderInterface> caller_sender =
rtc::scoped_refptr<RtpSenderInterface> caller_sender =
caller()->AddTrack(caller_track);
// Add receive video, from callee to caller.
rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
rtc::scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack();
rtc::scoped_refptr<webrtc::RtpSenderInterface> callee_sender =
rtc::scoped_refptr<RtpSenderInterface> callee_sender =
callee()->AddTrack(callee_track);
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
@ -494,15 +494,15 @@ TEST_P(PeerConnectionIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
// Add send video, from caller to callee.
rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
rtc::scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack();
rtc::scoped_refptr<webrtc::RtpSenderInterface> caller_sender =
rtc::scoped_refptr<RtpSenderInterface> caller_sender =
caller()->AddTrack(caller_track);
// Add receive video, from callee to caller.
rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
rtc::scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack();
rtc::scoped_refptr<webrtc::RtpSenderInterface> callee_sender =
rtc::scoped_refptr<RtpSenderInterface> callee_sender =
callee()->AddTrack(callee_track);
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
@ -654,9 +654,9 @@ TEST_P(PeerConnectionIntegrationTest, RotatedVideoWithCVOExtension) {
ConnectFakeSignaling();
// Add rotated video tracks.
caller()->AddTrack(
caller()->CreateLocalVideoTrackWithRotation(webrtc::kVideoRotation_90));
caller()->CreateLocalVideoTrackWithRotation(kVideoRotation_90));
callee()->AddTrack(
callee()->CreateLocalVideoTrackWithRotation(webrtc::kVideoRotation_270));
callee()->CreateLocalVideoTrackWithRotation(kVideoRotation_270));
// Wait for video frames to be received by both sides.
caller()->CreateAndSetAndSignalOffer();
@ -673,8 +673,8 @@ TEST_P(PeerConnectionIntegrationTest, RotatedVideoWithCVOExtension) {
EXPECT_EQ(4.0 / 3, callee()->local_rendered_aspect_ratio());
EXPECT_EQ(4.0 / 3, callee()->rendered_aspect_ratio());
// Ensure that the CVO bits were surfaced to the renderer.
EXPECT_EQ(webrtc::kVideoRotation_270, caller()->rendered_rotation());
EXPECT_EQ(webrtc::kVideoRotation_90, callee()->rendered_rotation());
EXPECT_EQ(kVideoRotation_270, caller()->rendered_rotation());
EXPECT_EQ(kVideoRotation_90, callee()->rendered_rotation());
}
// Test that when the CVO extension isn't supported, video is rotated the
@ -684,9 +684,9 @@ TEST_P(PeerConnectionIntegrationTest, RotatedVideoWithoutCVOExtension) {
ConnectFakeSignaling();
// Add rotated video tracks.
caller()->AddTrack(
caller()->CreateLocalVideoTrackWithRotation(webrtc::kVideoRotation_90));
caller()->CreateLocalVideoTrackWithRotation(kVideoRotation_90));
callee()->AddTrack(
callee()->CreateLocalVideoTrackWithRotation(webrtc::kVideoRotation_270));
callee()->CreateLocalVideoTrackWithRotation(kVideoRotation_270));
// Remove the CVO extension from the offered SDP.
callee()->SetReceivedSdpMunger([](cricket::SessionDescription* desc) {
@ -710,8 +710,8 @@ TEST_P(PeerConnectionIntegrationTest, RotatedVideoWithoutCVOExtension) {
EXPECT_EQ(3.0 / 4, callee()->local_rendered_aspect_ratio());
EXPECT_EQ(3.0 / 4, callee()->rendered_aspect_ratio());
// Expect that each endpoint is unaware of the rotation of the other endpoint.
EXPECT_EQ(webrtc::kVideoRotation_0, caller()->rendered_rotation());
EXPECT_EQ(webrtc::kVideoRotation_0, callee()->rendered_rotation());
EXPECT_EQ(kVideoRotation_0, caller()->rendered_rotation());
EXPECT_EQ(kVideoRotation_0, callee()->rendered_rotation());
}
// Test that if the answerer rejects the audio m= section, no audio is sent or
@ -899,9 +899,9 @@ TEST_F(PeerConnectionIntegrationTestPlanB, EnableAudioAfterRejecting) {
ConnectFakeSignaling();
// Add audio track, do normal offer/answer.
rtc::scoped_refptr<webrtc::AudioTrackInterface> track =
rtc::scoped_refptr<AudioTrackInterface> track =
caller()->CreateLocalAudioTrack();
rtc::scoped_refptr<webrtc::RtpSenderInterface> sender =
rtc::scoped_refptr<RtpSenderInterface> sender =
caller()->pc()->AddTrack(track, {"stream"}).MoveValue();
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
@ -974,7 +974,7 @@ TEST_F(PeerConnectionIntegrationTestUnifiedPlan,
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
// Add one-directional video, from caller to callee.
rtc::scoped_refptr<webrtc::VideoTrackInterface> track =
rtc::scoped_refptr<VideoTrackInterface> track =
caller()->CreateLocalVideoTrack();
RtpTransceiverInit video_transceiver_init;
@ -988,7 +988,7 @@ TEST_F(PeerConnectionIntegrationTestUnifiedPlan,
// Add receive direction.
video_sender->SetDirectionWithError(RtpTransceiverDirection::kSendRecv);
rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
rtc::scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack();
callee()->AddTrack(callee_track);
@ -1348,11 +1348,11 @@ TEST_P(PeerConnectionIntegrationTest, NewGetStatsManyAudioAndManyVideoStreams) {
audio_sender_1->track()->id(), video_sender_1->track()->id(),
audio_sender_2->track()->id(), video_sender_2->track()->id()};
rtc::scoped_refptr<const webrtc::RTCStatsReport> caller_report =
rtc::scoped_refptr<const RTCStatsReport> caller_report =
caller()->NewGetStats();
ASSERT_TRUE(caller_report);
auto outbound_stream_stats =
caller_report->GetStatsOfType<webrtc::RTCOutboundRtpStreamStats>();
caller_report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_EQ(outbound_stream_stats.size(), 4u);
std::vector<std::string> outbound_track_ids;
for (const auto& stat : outbound_stream_stats) {
@ -1373,11 +1373,11 @@ TEST_P(PeerConnectionIntegrationTest, NewGetStatsManyAudioAndManyVideoStreams) {
}
EXPECT_THAT(outbound_track_ids, UnorderedElementsAreArray(track_ids));
rtc::scoped_refptr<const webrtc::RTCStatsReport> callee_report =
rtc::scoped_refptr<const RTCStatsReport> callee_report =
callee()->NewGetStats();
ASSERT_TRUE(callee_report);
auto inbound_stream_stats =
callee_report->GetStatsOfType<webrtc::RTCInboundRtpStreamStats>();
callee_report->GetStatsOfType<RTCInboundRtpStreamStats>();
ASSERT_EQ(4u, inbound_stream_stats.size());
std::vector<std::string> inbound_track_ids;
for (const auto& stat : inbound_stream_stats) {
@ -1412,11 +1412,10 @@ TEST_P(PeerConnectionIntegrationTest,
// 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 webrtc::RTCStatsReport> report =
callee()->NewGetStats();
rtc::scoped_refptr<const RTCStatsReport> report = callee()->NewGetStats();
ASSERT_NE(nullptr, report);
auto inbound_stream_stats =
report->GetStatsOfType<webrtc::RTCInboundRtpStreamStats>();
report->GetStatsOfType<RTCInboundRtpStreamStats>();
ASSERT_EQ(1U, inbound_stream_stats.size());
ASSERT_TRUE(inbound_stream_stats[0]->bytes_received.is_defined());
ASSERT_GT(*inbound_stream_stats[0]->bytes_received, 0U);
@ -1459,12 +1458,10 @@ TEST_P(PeerConnectionIntegrationTest,
media_expectations.CalleeExpectsSomeVideo(1);
ASSERT_TRUE(ExpectNewFrames(media_expectations));
rtc::scoped_refptr<const webrtc::RTCStatsReport> report =
callee()->NewGetStats();
rtc::scoped_refptr<const RTCStatsReport> report = callee()->NewGetStats();
ASSERT_NE(nullptr, report);
auto inbound_rtps =
report->GetStatsOfType<webrtc::RTCInboundRtpStreamStats>();
auto inbound_rtps = report->GetStatsOfType<RTCInboundRtpStreamStats>();
auto index = FindFirstMediaStatsIndexByKind("audio", inbound_rtps);
ASSERT_GE(index, 0);
EXPECT_TRUE(inbound_rtps[index]->audio_level.is_defined());
@ -1655,18 +1652,18 @@ TEST_P(PeerConnectionIntegrationTest, IceStatesReachCompletion) {
callee()->AddAudioVideoTracks();
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceGatheringComplete,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringComplete,
caller()->ice_gathering_state(), kMaxWaitForFramesMs);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceGatheringComplete,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringComplete,
callee()->ice_gathering_state(), kMaxWaitForFramesMs);
// After the best candidate pair is selected and all candidates are signaled,
// the ICE connection state should reach "complete".
// TODO(deadbeef): Currently, the ICE "controlled" agent (the
// answerer/"callee" by default) only reaches "connected". When this is
// fixed, this test should be updated.
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
caller()->ice_connection_state(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kDefaultTimeout);
}
@ -1679,9 +1676,9 @@ constexpr int kOnlyLocalPorts = cricket::PORTALLOCATOR_DISABLE_STUN |
TEST_P(PeerConnectionIntegrationTest,
IceStatesReachCompletionWithRemoteHostname) {
auto caller_resolver_factory =
std::make_unique<NiceMock<webrtc::MockAsyncDnsResolverFactory>>();
std::make_unique<NiceMock<MockAsyncDnsResolverFactory>>();
auto callee_resolver_factory =
std::make_unique<NiceMock<webrtc::MockAsyncDnsResolverFactory>>();
std::make_unique<NiceMock<MockAsyncDnsResolverFactory>>();
auto callee_async_resolver =
std::make_unique<NiceMock<MockAsyncDnsResolver>>();
auto caller_async_resolver =
@ -1695,12 +1692,12 @@ TEST_P(PeerConnectionIntegrationTest,
// P2PTransportChannel.
EXPECT_CALL(*caller_resolver_factory, Create())
.WillOnce(Return(ByMove(std::move(caller_async_resolver))));
webrtc::PeerConnectionDependencies caller_deps(nullptr);
PeerConnectionDependencies caller_deps(nullptr);
caller_deps.async_dns_resolver_factory = std::move(caller_resolver_factory);
EXPECT_CALL(*callee_resolver_factory, Create())
.WillOnce(Return(ByMove(std::move(callee_async_resolver))));
webrtc::PeerConnectionDependencies callee_deps(nullptr);
PeerConnectionDependencies callee_deps(nullptr);
callee_deps.async_dns_resolver_factory = std::move(callee_resolver_factory);
PeerConnectionInterface::RTCConfiguration config;
@ -1719,9 +1716,9 @@ TEST_P(PeerConnectionIntegrationTest,
// Enable hostname candidates with mDNS names.
caller()->SetMdnsResponder(
std::make_unique<webrtc::FakeMdnsResponder>(network_thread()));
std::make_unique<FakeMdnsResponder>(network_thread()));
callee()->SetMdnsResponder(
std::make_unique<webrtc::FakeMdnsResponder>(network_thread()));
std::make_unique<FakeMdnsResponder>(network_thread()));
SetPortAllocatorFlags(kOnlyLocalPorts, kOnlyLocalPorts);
@ -1730,18 +1727,18 @@ TEST_P(PeerConnectionIntegrationTest,
callee()->AddAudioVideoTracks();
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
caller()->ice_connection_state(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kDefaultTimeout);
// Part of reporting the stats will occur on the network thread, so flush it
// before checking NumEvents.
SendTask(network_thread(), [] {});
EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(
"WebRTC.PeerConnection.CandidatePairType_UDP",
webrtc::kIceCandidatePairHostNameHostName));
EXPECT_METRIC_EQ(
1, metrics::NumEvents("WebRTC.PeerConnection.CandidatePairType_UDP",
kIceCandidatePairHostNameHostName));
DestroyPeerConnections();
}
@ -1862,9 +1859,9 @@ TEST_P(PeerConnectionIntegrationIceStatesTest, MAYBE_VerifyBestConnection) {
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
caller()->ice_connection_state(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kDefaultTimeout);
// Part of reporting the stats will occur on the network thread, so flush it
@ -1872,10 +1869,10 @@ TEST_P(PeerConnectionIntegrationIceStatesTest, MAYBE_VerifyBestConnection) {
SendTask(network_thread(), [] {});
// TODO(bugs.webrtc.org/9456): Fix it.
const int num_best_ipv4 = webrtc::metrics::NumEvents(
"WebRTC.PeerConnection.IPMetrics", webrtc::kBestConnections_IPv4);
const int num_best_ipv6 = webrtc::metrics::NumEvents(
"WebRTC.PeerConnection.IPMetrics", webrtc::kBestConnections_IPv6);
const int num_best_ipv4 = metrics::NumEvents(
"WebRTC.PeerConnection.IPMetrics", kBestConnections_IPv4);
const int num_best_ipv6 = metrics::NumEvents(
"WebRTC.PeerConnection.IPMetrics", kBestConnections_IPv6);
if (TestIPv6()) {
// When IPv6 is enabled, we should prefer an IPv6 connection over an IPv4
// connection.
@ -1886,12 +1883,12 @@ TEST_P(PeerConnectionIntegrationIceStatesTest, MAYBE_VerifyBestConnection) {
EXPECT_METRIC_EQ(0, num_best_ipv6);
}
EXPECT_METRIC_EQ(0, webrtc::metrics::NumEvents(
"WebRTC.PeerConnection.CandidatePairType_UDP",
webrtc::kIceCandidatePairHostHost));
EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(
"WebRTC.PeerConnection.CandidatePairType_UDP",
webrtc::kIceCandidatePairHostPublicHostPublic));
EXPECT_METRIC_EQ(
0, metrics::NumEvents("WebRTC.PeerConnection.CandidatePairType_UDP",
kIceCandidatePairHostHost));
EXPECT_METRIC_EQ(
1, metrics::NumEvents("WebRTC.PeerConnection.CandidatePairType_UDP",
kIceCandidatePairHostPublicHostPublic));
}
constexpr uint32_t kFlagsIPv4NoStun = cricket::PORTALLOCATOR_DISABLE_TCP |
@ -1931,17 +1928,17 @@ TEST_P(PeerConnectionIntegrationTest, MediaContinuesFlowingAfterIceRestart) {
callee()->AddAudioVideoTracks();
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
caller()->ice_connection_state(), kMaxWaitForFramesMs);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kMaxWaitForFramesMs);
// To verify that the ICE restart actually occurs, get
// ufrag/password/candidates before and after restart.
// Create an SDP string of the first audio candidate for both clients.
const webrtc::IceCandidateCollection* audio_candidates_caller =
const IceCandidateCollection* audio_candidates_caller =
caller()->pc()->local_description()->candidates(0);
const webrtc::IceCandidateCollection* audio_candidates_callee =
const IceCandidateCollection* audio_candidates_callee =
callee()->pc()->local_description()->candidates(0);
ASSERT_GT(audio_candidates_caller->count(), 0u);
ASSERT_GT(audio_candidates_callee->count(), 0u);
@ -1964,9 +1961,9 @@ TEST_P(PeerConnectionIntegrationTest, MediaContinuesFlowingAfterIceRestart) {
caller()->SetOfferAnswerOptions(IceRestartOfferAnswerOptions());
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
caller()->ice_connection_state(), kMaxWaitForFramesMs);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kMaxWaitForFramesMs);
// Grab the ufrags/candidates again.
@ -2141,9 +2138,9 @@ TEST_F(PeerConnectionIntegrationTestPlanB,
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kMaxWaitForActivationMs);
// Wait for ICE to complete, without any tracks being set.
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
caller()->ice_connection_state(), kMaxWaitForFramesMs);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kMaxWaitForFramesMs);
// Now set the tracks, and expect frames to immediately start flowing.
EXPECT_TRUE(
@ -2182,9 +2179,9 @@ TEST_F(PeerConnectionIntegrationTestUnifiedPlan,
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kMaxWaitForActivationMs);
// Wait for ICE to complete, without any tracks being set.
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
caller()->ice_connection_state(), kMaxWaitForFramesMs);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kMaxWaitForFramesMs);
// Now set the tracks, and expect frames to immediately start flowing.
auto callee_audio_sender = callee()->pc()->GetSenders()[0];
@ -2279,21 +2276,21 @@ TEST_P(PeerConnectionIntegrationTestWithFakeClock,
});
PeerConnectionInterface::RTCConfiguration client_1_config;
webrtc::PeerConnectionInterface::IceServer ice_server_1;
PeerConnectionInterface::IceServer ice_server_1;
ice_server_1.urls.push_back("turn:88.88.88.0:3478");
ice_server_1.username = "test";
ice_server_1.password = "test";
client_1_config.servers.push_back(ice_server_1);
client_1_config.type = webrtc::PeerConnectionInterface::kRelay;
client_1_config.type = PeerConnectionInterface::kRelay;
client_1_config.presume_writable_when_fully_relayed = true;
PeerConnectionInterface::RTCConfiguration client_2_config;
webrtc::PeerConnectionInterface::IceServer ice_server_2;
PeerConnectionInterface::IceServer ice_server_2;
ice_server_2.urls.push_back("turn:99.99.99.0:3478");
ice_server_2.username = "test";
ice_server_2.password = "test";
client_2_config.servers.push_back(ice_server_2);
client_2_config.type = webrtc::PeerConnectionInterface::kRelay;
client_2_config.type = PeerConnectionInterface::kRelay;
client_2_config.presume_writable_when_fully_relayed = true;
ASSERT_TRUE(
@ -2326,22 +2323,22 @@ TEST_P(PeerConnectionIntegrationTestWithFakeClock,
caller()->AddAudioTrack();
// Call getStats, assert there are no candidates.
rtc::scoped_refptr<const webrtc::RTCStatsReport> first_report =
rtc::scoped_refptr<const RTCStatsReport> first_report =
caller()->NewGetStats();
ASSERT_TRUE(first_report);
auto first_candidate_stats =
first_report->GetStatsOfType<webrtc::RTCLocalIceCandidateStats>();
first_report->GetStatsOfType<RTCLocalIceCandidateStats>();
ASSERT_EQ(first_candidate_stats.size(), 0u);
// Create an offer at the caller and set it as remote description on the
// callee.
caller()->CreateAndSetAndSignalOffer();
// Call getStats again, assert there are candidates now.
rtc::scoped_refptr<const webrtc::RTCStatsReport> second_report =
rtc::scoped_refptr<const RTCStatsReport> second_report =
caller()->NewGetStats();
ASSERT_TRUE(second_report);
auto second_candidate_stats =
second_report->GetStatsOfType<webrtc::RTCLocalIceCandidateStats>();
second_report->GetStatsOfType<RTCLocalIceCandidateStats>();
ASSERT_NE(second_candidate_stats.size(), 0u);
// The fake clock ensures that no time has passed so the cache must have been
@ -2362,17 +2359,17 @@ TEST_P(PeerConnectionIntegrationTestWithFakeClock,
kDefaultTimeout, FakeClock());
// Call getStats, assert there are no candidates.
rtc::scoped_refptr<const webrtc::RTCStatsReport> first_report =
rtc::scoped_refptr<const RTCStatsReport> first_report =
caller()->NewGetStats();
ASSERT_TRUE(first_report);
auto first_candidate_stats =
first_report->GetStatsOfType<webrtc::RTCRemoteIceCandidateStats>();
first_report->GetStatsOfType<RTCRemoteIceCandidateStats>();
ASSERT_EQ(first_candidate_stats.size(), 0u);
// Add a "fake" candidate.
absl::optional<RTCError> result;
caller()->pc()->AddIceCandidate(
absl::WrapUnique(webrtc::CreateIceCandidate(
absl::WrapUnique(CreateIceCandidate(
"", 0,
"candidate:2214029314 1 udp 2122260223 127.0.0.1 49152 typ host",
nullptr)),
@ -2381,11 +2378,11 @@ TEST_P(PeerConnectionIntegrationTestWithFakeClock,
ASSERT_TRUE(result.value().ok());
// Call getStats again, assert there is a remote candidate now.
rtc::scoped_refptr<const webrtc::RTCStatsReport> second_report =
rtc::scoped_refptr<const RTCStatsReport> second_report =
caller()->NewGetStats();
ASSERT_TRUE(second_report);
auto second_candidate_stats =
second_report->GetStatsOfType<webrtc::RTCRemoteIceCandidateStats>();
second_report->GetStatsOfType<RTCRemoteIceCandidateStats>();
ASSERT_EQ(second_candidate_stats.size(), 1u);
// The fake clock ensures that no time has passed so the cache must have been
@ -2413,22 +2410,22 @@ TEST_P(PeerConnectionIntegrationTest, TurnCustomizerUsedForTurnConnections) {
turn_server_2_external_address);
PeerConnectionInterface::RTCConfiguration client_1_config;
webrtc::PeerConnectionInterface::IceServer ice_server_1;
PeerConnectionInterface::IceServer ice_server_1;
ice_server_1.urls.push_back("turn:88.88.88.0:3478");
ice_server_1.username = "test";
ice_server_1.password = "test";
client_1_config.servers.push_back(ice_server_1);
client_1_config.type = webrtc::PeerConnectionInterface::kRelay;
client_1_config.type = PeerConnectionInterface::kRelay;
auto* customizer1 = CreateTurnCustomizer();
client_1_config.turn_customizer = customizer1;
PeerConnectionInterface::RTCConfiguration client_2_config;
webrtc::PeerConnectionInterface::IceServer ice_server_2;
PeerConnectionInterface::IceServer ice_server_2;
ice_server_2.urls.push_back("turn:99.99.99.0:3478");
ice_server_2.username = "test";
ice_server_2.password = "test";
client_2_config.servers.push_back(ice_server_2);
client_2_config.type = webrtc::PeerConnectionInterface::kRelay;
client_2_config.type = PeerConnectionInterface::kRelay;
auto* customizer2 = CreateTurnCustomizer();
client_2_config.turn_customizer = customizer2;
@ -2460,18 +2457,18 @@ TEST_P(PeerConnectionIntegrationTest, TCPUsedForTurnConnections) {
CreateTurnServer(turn_server_internal_address, turn_server_external_address,
cricket::PROTO_TCP);
webrtc::PeerConnectionInterface::IceServer ice_server;
PeerConnectionInterface::IceServer ice_server;
ice_server.urls.push_back("turn:88.88.88.0:3478?transport=tcp");
ice_server.username = "test";
ice_server.password = "test";
PeerConnectionInterface::RTCConfiguration client_1_config;
client_1_config.servers.push_back(ice_server);
client_1_config.type = webrtc::PeerConnectionInterface::kRelay;
client_1_config.type = PeerConnectionInterface::kRelay;
PeerConnectionInterface::RTCConfiguration client_2_config;
client_2_config.servers.push_back(ice_server);
client_2_config.type = webrtc::PeerConnectionInterface::kRelay;
client_2_config.type = PeerConnectionInterface::kRelay;
ASSERT_TRUE(
CreatePeerConnectionWrappersWithConfig(client_1_config, client_2_config));
@ -2482,7 +2479,7 @@ TEST_P(PeerConnectionIntegrationTest, TCPUsedForTurnConnections) {
callee()->AddAudioVideoTracks();
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kMaxWaitForFramesMs);
MediaExpectations media_expectations;
@ -2506,20 +2503,20 @@ TEST_P(PeerConnectionIntegrationTest,
CreateTurnServer(turn_server_internal_address, turn_server_external_address,
cricket::PROTO_TLS, "88.88.88.0");
webrtc::PeerConnectionInterface::IceServer ice_server;
PeerConnectionInterface::IceServer ice_server;
ice_server.urls.push_back("turns:88.88.88.0:3478?transport=tcp");
ice_server.username = "test";
ice_server.password = "test";
PeerConnectionInterface::RTCConfiguration client_1_config;
client_1_config.servers.push_back(ice_server);
client_1_config.type = webrtc::PeerConnectionInterface::kRelay;
client_1_config.type = PeerConnectionInterface::kRelay;
PeerConnectionInterface::RTCConfiguration client_2_config;
client_2_config.servers.push_back(ice_server);
// Setting the type to kRelay forces the connection to go through a TURN
// server.
client_2_config.type = webrtc::PeerConnectionInterface::kRelay;
client_2_config.type = PeerConnectionInterface::kRelay;
// Get a copy to the pointer so we can verify calls later.
rtc::TestCertificateVerifier* client_1_cert_verifier =
@ -2530,10 +2527,10 @@ TEST_P(PeerConnectionIntegrationTest,
client_2_cert_verifier->verify_certificate_ = true;
// Create the dependencies with the test certificate verifier.
webrtc::PeerConnectionDependencies client_1_deps(nullptr);
PeerConnectionDependencies client_1_deps(nullptr);
client_1_deps.tls_cert_verifier =
std::unique_ptr<rtc::TestCertificateVerifier>(client_1_cert_verifier);
webrtc::PeerConnectionDependencies client_2_deps(nullptr);
PeerConnectionDependencies client_2_deps(nullptr);
client_2_deps.tls_cert_verifier =
std::unique_ptr<rtc::TestCertificateVerifier>(client_2_cert_verifier);
@ -2644,7 +2641,7 @@ TEST_P(PeerConnectionIntegrationTest, GetSourcesAudio) {
ASSERT_GT(receiver->GetParameters().encodings.size(), 0u);
EXPECT_EQ(receiver->GetParameters().encodings[0].ssrc,
sources[0].source_id());
EXPECT_EQ(webrtc::RtpSourceType::SSRC, sources[0].source_type());
EXPECT_EQ(RtpSourceType::SSRC, sources[0].source_type());
}
TEST_P(PeerConnectionIntegrationTest, GetSourcesVideo) {
@ -2665,7 +2662,7 @@ TEST_P(PeerConnectionIntegrationTest, GetSourcesVideo) {
ASSERT_GT(sources.size(), 0u);
EXPECT_EQ(receiver->GetParameters().encodings[0].ssrc,
sources[0].source_id());
EXPECT_EQ(webrtc::RtpSourceType::SSRC, sources[0].source_type());
EXPECT_EQ(RtpSourceType::SSRC, sources[0].source_type());
}
TEST_P(PeerConnectionIntegrationTest, UnsignaledSsrcGetSourcesAudio) {
@ -2684,7 +2681,7 @@ TEST_P(PeerConnectionIntegrationTest, UnsignaledSsrcGetSourcesAudio) {
})(),
kDefaultTimeout);
ASSERT_GT(sources.size(), 0u);
EXPECT_EQ(webrtc::RtpSourceType::SSRC, sources[0].source_type());
EXPECT_EQ(RtpSourceType::SSRC, sources[0].source_type());
}
TEST_P(PeerConnectionIntegrationTest, UnsignaledSsrcGetSourcesVideo) {
@ -2703,7 +2700,7 @@ TEST_P(PeerConnectionIntegrationTest, UnsignaledSsrcGetSourcesVideo) {
})(),
kDefaultTimeout);
ASSERT_GT(sources.size(), 0u);
EXPECT_EQ(webrtc::RtpSourceType::SSRC, sources[0].source_type());
EXPECT_EQ(RtpSourceType::SSRC, sources[0].source_type());
}
// Similar to the above test, except instead of waiting until GetSources() is
@ -2728,7 +2725,7 @@ TEST_P(PeerConnectionIntegrationTest,
std::vector<RtpSource> sources = receiver->GetSources();
// SSRC history must not be cleared since the reception of the first frame.
ASSERT_GT(sources.size(), 0u);
EXPECT_EQ(webrtc::RtpSourceType::SSRC, sources[0].source_type());
EXPECT_EQ(RtpSourceType::SSRC, sources[0].source_type());
}
TEST_P(PeerConnectionIntegrationTest, UnsignaledSsrcGetParametersAudio) {
@ -2791,9 +2788,9 @@ TEST_F(PeerConnectionIntegrationTestPlanB, RemoveAndAddTrackWithNewStreamId) {
ConnectFakeSignaling();
// Add track using stream 1, do offer/answer.
rtc::scoped_refptr<webrtc::AudioTrackInterface> track =
rtc::scoped_refptr<AudioTrackInterface> track =
caller()->CreateLocalAudioTrack();
rtc::scoped_refptr<webrtc::RtpSenderInterface> sender =
rtc::scoped_refptr<RtpSenderInterface> sender =
caller()->AddTrack(track, {"stream_1"});
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
@ -2825,8 +2822,8 @@ TEST_P(PeerConnectionIntegrationTest, RtcEventLogOutputWriteCalled) {
.WillByDefault(::testing::Return(true));
EXPECT_CALL(*output, Write(::testing::A<absl::string_view>()))
.Times(::testing::AtLeast(1));
EXPECT_TRUE(caller()->pc()->StartRtcEventLog(
std::move(output), webrtc::RtcEventLog::kImmediateOutput));
EXPECT_TRUE(caller()->pc()->StartRtcEventLog(std::move(output),
RtcEventLog::kImmediateOutput));
caller()->AddAudioVideoTracks();
caller()->CreateAndSetAndSignalOffer();
@ -2900,8 +2897,7 @@ TEST_P(PeerConnectionIntegrationTest, DisableAndEnableAudioPlayout) {
double GetAudioEnergyStat(PeerConnectionIntegrationWrapper* pc) {
auto report = pc->NewGetStats();
auto inbound_rtps =
report->GetStatsOfType<webrtc::RTCInboundRtpStreamStats>();
auto inbound_rtps = report->GetStatsOfType<RTCInboundRtpStreamStats>();
RTC_CHECK(!inbound_rtps.empty());
auto* inbound_rtp = inbound_rtps[0];
if (!inbound_rtp->total_audio_energy.is_defined()) {
@ -2974,20 +2970,20 @@ TEST_P(PeerConnectionIntegrationTest,
ASSERT_TRUE_WAIT(DtlsConnected(), kDefaultTimeout);
ASSERT_NE(nullptr, caller()->event_log_factory());
ASSERT_NE(nullptr, callee()->event_log_factory());
webrtc::FakeRtcEventLog* caller_event_log =
FakeRtcEventLog* caller_event_log =
caller()->event_log_factory()->last_log_created();
webrtc::FakeRtcEventLog* callee_event_log =
FakeRtcEventLog* callee_event_log =
callee()->event_log_factory()->last_log_created();
ASSERT_NE(nullptr, caller_event_log);
ASSERT_NE(nullptr, callee_event_log);
int caller_ice_config_count = caller_event_log->GetEventCount(
webrtc::RtcEvent::Type::IceCandidatePairConfig);
int caller_ice_event_count = caller_event_log->GetEventCount(
webrtc::RtcEvent::Type::IceCandidatePairEvent);
int callee_ice_config_count = callee_event_log->GetEventCount(
webrtc::RtcEvent::Type::IceCandidatePairConfig);
int callee_ice_event_count = callee_event_log->GetEventCount(
webrtc::RtcEvent::Type::IceCandidatePairEvent);
int caller_ice_config_count =
caller_event_log->GetEventCount(RtcEvent::Type::IceCandidatePairConfig);
int caller_ice_event_count =
caller_event_log->GetEventCount(RtcEvent::Type::IceCandidatePairEvent);
int callee_ice_config_count =
callee_event_log->GetEventCount(RtcEvent::Type::IceCandidatePairConfig);
int callee_ice_event_count =
callee_event_log->GetEventCount(RtcEvent::Type::IceCandidatePairEvent);
EXPECT_LT(0, caller_ice_config_count);
EXPECT_LT(0, caller_ice_event_count);
EXPECT_LT(0, callee_ice_config_count);
@ -3001,20 +2997,20 @@ TEST_P(PeerConnectionIntegrationTest, RegatherAfterChangingIceTransportType) {
CreateTurnServer(turn_server_internal_address, turn_server_external_address);
webrtc::PeerConnectionInterface::IceServer ice_server;
PeerConnectionInterface::IceServer ice_server;
ice_server.urls.push_back("turn:88.88.88.0:3478");
ice_server.username = "test";
ice_server.password = "test";
PeerConnectionInterface::RTCConfiguration caller_config;
caller_config.servers.push_back(ice_server);
caller_config.type = webrtc::PeerConnectionInterface::kRelay;
caller_config.type = PeerConnectionInterface::kRelay;
caller_config.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
caller_config.surface_ice_candidates_on_ice_transport_type_changed = true;
PeerConnectionInterface::RTCConfiguration callee_config;
callee_config.servers.push_back(ice_server);
callee_config.type = webrtc::PeerConnectionInterface::kRelay;
callee_config.type = PeerConnectionInterface::kRelay;
callee_config.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
callee_config.surface_ice_candidates_on_ice_transport_type_changed = true;
@ -3031,9 +3027,9 @@ TEST_P(PeerConnectionIntegrationTest, RegatherAfterChangingIceTransportType) {
// kIceGatheringComplete (see
// P2PTransportChannel::OnCandidatesAllocationDone), and consequently not
// kIceConnectionComplete.
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
caller()->ice_connection_state(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kDefaultTimeout);
// Note that we cannot use the metric
// `WebRTC.PeerConnection.CandidatePairType_UDP` in this test since this
@ -3046,7 +3042,7 @@ TEST_P(PeerConnectionIntegrationTest, RegatherAfterChangingIceTransportType) {
// Loosen the caller's candidate filter.
caller_config = caller()->pc()->GetConfiguration();
caller_config.type = webrtc::PeerConnectionInterface::kAll;
caller_config.type = PeerConnectionInterface::kAll;
caller()->pc()->SetConfiguration(caller_config);
// We should have gathered a new host candidate.
EXPECT_EQ_WAIT(cricket::LOCAL_PORT_TYPE,
@ -3054,7 +3050,7 @@ TEST_P(PeerConnectionIntegrationTest, RegatherAfterChangingIceTransportType) {
// Loosen the callee's candidate filter.
callee_config = callee()->pc()->GetConfiguration();
callee_config.type = webrtc::PeerConnectionInterface::kAll;
callee_config.type = PeerConnectionInterface::kAll;
callee()->pc()->SetConfiguration(callee_config);
EXPECT_EQ_WAIT(cricket::LOCAL_PORT_TYPE,
callee()->last_candidate_gathered().type(), kDefaultTimeout);
@ -3084,19 +3080,19 @@ TEST_P(PeerConnectionIntegrationTest, OnIceCandidateError) {
CreateTurnServer(turn_server_internal_address, turn_server_external_address);
webrtc::PeerConnectionInterface::IceServer ice_server;
PeerConnectionInterface::IceServer ice_server;
ice_server.urls.push_back("turn:88.88.88.0:3478");
ice_server.username = "test";
ice_server.password = "123";
PeerConnectionInterface::RTCConfiguration caller_config;
caller_config.servers.push_back(ice_server);
caller_config.type = webrtc::PeerConnectionInterface::kRelay;
caller_config.type = PeerConnectionInterface::kRelay;
caller_config.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
PeerConnectionInterface::RTCConfiguration callee_config;
callee_config.servers.push_back(ice_server);
callee_config.type = webrtc::PeerConnectionInterface::kRelay;
callee_config.type = PeerConnectionInterface::kRelay;
callee_config.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
ASSERT_TRUE(
@ -3115,19 +3111,19 @@ TEST_P(PeerConnectionIntegrationTest, OnIceCandidateError) {
}
TEST_P(PeerConnectionIntegrationTest, OnIceCandidateErrorWithEmptyAddress) {
webrtc::PeerConnectionInterface::IceServer ice_server;
PeerConnectionInterface::IceServer ice_server;
ice_server.urls.push_back("turn:127.0.0.1:3478?transport=tcp");
ice_server.username = "test";
ice_server.password = "test";
PeerConnectionInterface::RTCConfiguration caller_config;
caller_config.servers.push_back(ice_server);
caller_config.type = webrtc::PeerConnectionInterface::kRelay;
caller_config.type = PeerConnectionInterface::kRelay;
caller_config.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
PeerConnectionInterface::RTCConfiguration callee_config;
callee_config.servers.push_back(ice_server);
callee_config.type = webrtc::PeerConnectionInterface::kRelay;
callee_config.type = PeerConnectionInterface::kRelay;
callee_config.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
ASSERT_TRUE(
@ -3697,7 +3693,7 @@ TEST_P(PeerConnectionIntegrationTest, EndToEndRtpSenderVideoEncoderSelector) {
CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/true));
ConnectFakeSignaling();
// Add one-directional video, from caller to callee.
rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
rtc::scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack();
auto sender = caller()->AddTrack(caller_track);
PeerConnectionInterface::RTCOfferAnswerOptions options;
@ -3722,7 +3718,7 @@ TEST_P(PeerConnectionIntegrationTest, EndToEndRtpSenderVideoEncoderSelector) {
}
int NacksReceivedCount(PeerConnectionIntegrationWrapper& pc) {
rtc::scoped_refptr<const webrtc::RTCStatsReport> report = pc.NewGetStats();
rtc::scoped_refptr<const RTCStatsReport> report = pc.NewGetStats();
auto sender_stats = report->GetStatsOfType<RTCOutboundRtpStreamStats>();
if (sender_stats.size() != 1) {
ADD_FAILURE();
@ -3735,7 +3731,7 @@ int NacksReceivedCount(PeerConnectionIntegrationWrapper& pc) {
}
int NacksSentCount(PeerConnectionIntegrationWrapper& pc) {
rtc::scoped_refptr<const webrtc::RTCStatsReport> report = pc.NewGetStats();
rtc::scoped_refptr<const RTCStatsReport> report = pc.NewGetStats();
auto receiver_stats = report->GetStatsOfType<RTCInboundRtpStreamStats>();
if (receiver_stats.size() != 1) {
ADD_FAILURE();

219
pc/peer_connection_interface_unittest.cc
View File

@ -474,8 +474,7 @@ bool GetFirstSsrc(const cricket::ContentInfo* content_info, int* ssrc) {
// Get the ufrags out of an SDP blob. Useful for testing ICE restart
// behavior.
std::vector<std::string> GetUfrags(
const webrtc::SessionDescriptionInterface* desc) {
std::vector<std::string> GetUfrags(const SessionDescriptionInterface* desc) {
std::vector<std::string> ufrags;
for (const cricket::TransportInfo& info :
desc->description()->transport_infos()) {
@ -544,21 +543,19 @@ rtc::scoped_refptr<StreamCollection> CreateStreamCollection(
StreamCollection::Create());
for (int i = 0; i < number_of_streams; ++i) {
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
webrtc::MediaStream::Create(kStreams[i]));
rtc::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<webrtc::AudioTrackInterface> audio_track(
webrtc::AudioTrack::Create(kAudioTracks[i * tracks_per_stream + j],
nullptr));
rtc::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<webrtc::VideoTrackInterface> video_track(
webrtc::VideoTrack::Create(kVideoTracks[i * tracks_per_stream + j],
webrtc::FakeVideoTrackSource::Create(),
rtc::Thread::Current()));
rtc::scoped_refptr<VideoTrackInterface> video_track(VideoTrack::Create(
kVideoTracks[i * tracks_per_stream + j],
FakeVideoTrackSource::Create(), rtc::Thread::Current()));
stream->AddTrack(video_track);
}
@ -578,10 +575,10 @@ bool CompareStreamCollections(StreamCollectionInterface* s1,
if (s1->at(i)->id() != s2->at(i)->id()) {
return false;
}
webrtc::AudioTrackVector audio_tracks1 = s1->at(i)->GetAudioTracks();
webrtc::AudioTrackVector audio_tracks2 = s2->at(i)->GetAudioTracks();
webrtc::VideoTrackVector video_tracks1 = s1->at(i)->GetVideoTracks();
webrtc::VideoTrackVector video_tracks2 = s2->at(i)->GetVideoTracks();
AudioTrackVector audio_tracks1 = s1->at(i)->GetAudioTracks();
AudioTrackVector audio_tracks2 = s2->at(i)->GetAudioTracks();
VideoTrackVector video_tracks1 = s1->at(i)->GetVideoTracks();
VideoTrackVector video_tracks2 = s2->at(i)->GetVideoTracks();
if (audio_tracks1.size() != audio_tracks2.size()) {
return false;
@ -630,7 +627,7 @@ class MockTrackObserver : public ObserverInterface {
// constraints are propagated into the PeerConnection's MediaConfig. These
// settings are intended for MediaChannel constructors, but that is not
// exercised by these unittest.
class PeerConnectionFactoryForTest : public webrtc::PeerConnectionFactory {
class PeerConnectionFactoryForTest : public PeerConnectionFactory {
public:
static rtc::scoped_refptr<PeerConnectionFactoryForTest>
CreatePeerConnectionFactoryForTest() {
@ -665,7 +662,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
main_(vss_.get()),
sdp_semantics_(sdp_semantics) {
#ifdef WEBRTC_ANDROID
webrtc::InitializeAndroidObjects();
InitializeAndroidObjects();
#endif
}
@ -673,22 +670,16 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
// Use fake audio capture module since we're only testing the interface
// level, and using a real one could make tests flaky when run in parallel.
fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
pc_factory_ = webrtc::CreatePeerConnectionFactory(
pc_factory_ = CreatePeerConnectionFactory(
rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
rtc::scoped_refptr<webrtc::AudioDeviceModule>(
fake_audio_capture_module_),
webrtc::CreateBuiltinAudioEncoderFactory(),
webrtc::CreateBuiltinAudioDecoderFactory(),
std::make_unique<webrtc::VideoEncoderFactoryTemplate<
webrtc::LibvpxVp8EncoderTemplateAdapter,
webrtc::LibvpxVp9EncoderTemplateAdapter,
webrtc::OpenH264EncoderTemplateAdapter,
webrtc::LibaomAv1EncoderTemplateAdapter>>(),
std::make_unique<webrtc::VideoDecoderFactoryTemplate<
webrtc::LibvpxVp8DecoderTemplateAdapter,
webrtc::LibvpxVp9DecoderTemplateAdapter,
webrtc::OpenH264DecoderTemplateAdapter,
webrtc::Dav1dDecoderTemplateAdapter>>(),
rtc::scoped_refptr<AudioDeviceModule>(fake_audio_capture_module_),
CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
std::make_unique<VideoEncoderFactoryTemplate<
LibvpxVp8EncoderTemplateAdapter, LibvpxVp9EncoderTemplateAdapter,
OpenH264EncoderTemplateAdapter, LibaomAv1EncoderTemplateAdapter>>(),
std::make_unique<VideoDecoderFactoryTemplate<
LibvpxVp8DecoderTemplateAdapter, LibvpxVp9DecoderTemplateAdapter,
OpenH264DecoderTemplateAdapter, Dav1dDecoderTemplateAdapter>>(),
nullptr /* audio_mixer */, nullptr /* audio_processing */);
ASSERT_TRUE(pc_factory_);
}
@ -946,8 +937,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
// Call the standards-compliant GetStats function.
bool DoGetRTCStats() {
auto callback =
rtc::make_ref_counted<webrtc::MockRTCStatsCollectorCallback>();
auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>();
pc_->GetStats(callback.get());
EXPECT_TRUE_WAIT(callback->called(), kTimeout);
return callback->called();
@ -987,14 +977,14 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
std::string sdp;
EXPECT_TRUE(offer->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> remote_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
CreateSessionDescription(SdpType::kOffer, sdp));
EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
}
void CreateAndSetRemoteOffer(const std::string& sdp) {
std::unique_ptr<SessionDescriptionInterface> remote_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
CreateSessionDescription(SdpType::kOffer, sdp));
EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
}
@ -1013,7 +1003,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
std::string sdp;
EXPECT_TRUE(answer->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> new_answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
CreateSessionDescription(SdpType::kAnswer, sdp));
EXPECT_TRUE(DoSetLocalDescription(std::move(new_answer)));
EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
}
@ -1025,7 +1015,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
std::string sdp;
EXPECT_TRUE(answer->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> pr_answer(
webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp));
CreateSessionDescription(SdpType::kPrAnswer, sdp));
EXPECT_TRUE(DoSetLocalDescription(std::move(pr_answer)));
EXPECT_EQ(PeerConnectionInterface::kHaveLocalPrAnswer, observer_.state_);
}
@ -1050,7 +1040,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
std::string sdp;
EXPECT_TRUE(offer->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> new_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
CreateSessionDescription(SdpType::kOffer, sdp));
EXPECT_TRUE(DoSetLocalDescription(std::move(new_offer)));
EXPECT_EQ(PeerConnectionInterface::kHaveLocalOffer, observer_.state_);
@ -1060,7 +1050,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
void CreateAnswerAsRemoteDescription(const std::string& sdp) {
std::unique_ptr<SessionDescriptionInterface> answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
CreateSessionDescription(SdpType::kAnswer, sdp));
ASSERT_TRUE(answer);
EXPECT_TRUE(DoSetRemoteDescription(std::move(answer)));
EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
@ -1068,12 +1058,12 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
void CreatePrAnswerAndAnswerAsRemoteDescription(const std::string& sdp) {
std::unique_ptr<SessionDescriptionInterface> pr_answer(
webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp));
CreateSessionDescription(SdpType::kPrAnswer, sdp));
ASSERT_TRUE(pr_answer);
EXPECT_TRUE(DoSetRemoteDescription(std::move(pr_answer)));
EXPECT_EQ(PeerConnectionInterface::kHaveRemotePrAnswer, observer_.state_);
std::unique_ptr<SessionDescriptionInterface> answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
CreateSessionDescription(SdpType::kAnswer, sdp));
ASSERT_TRUE(answer);
EXPECT_TRUE(DoSetRemoteDescription(std::move(answer)));
EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
@ -1117,8 +1107,8 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
std::string mediastream_id = kStreams[0];
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
webrtc::MediaStream::Create(mediastream_id));
rtc::scoped_refptr<MediaStreamInterface> stream(
MediaStream::Create(mediastream_id));
reference_collection_->AddStream(stream);
if (number_of_audio_tracks > 0) {
@ -1142,22 +1132,20 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
}
return std::unique_ptr<SessionDescriptionInterface>(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp_ms1));
CreateSessionDescription(SdpType::kOffer, sdp_ms1));
}
void AddAudioTrack(const std::string& track_id,
MediaStreamInterface* stream) {
rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
webrtc::AudioTrack::Create(track_id, nullptr));
rtc::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<webrtc::VideoTrackInterface> video_track(
webrtc::VideoTrack::Create(track_id,
webrtc::FakeVideoTrackSource::Create(),
rtc::Thread::Current()));
rtc::scoped_refptr<VideoTrackInterface> video_track(VideoTrack::Create(
track_id, FakeVideoTrackSource::Create(), rtc::Thread::Current()));
ASSERT_TRUE(stream->AddTrack(video_track));
}
@ -1217,7 +1205,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
std::string sdp;
EXPECT_TRUE((*desc)->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> remote_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
CreateSessionDescription(SdpType::kOffer, sdp));
EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
}
@ -1230,7 +1218,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
std::string sdp;
EXPECT_TRUE((*desc)->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> new_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
CreateSessionDescription(SdpType::kOffer, sdp));
EXPECT_TRUE(DoSetLocalDescription(std::move(new_offer)));
EXPECT_EQ(PeerConnectionInterface::kHaveLocalOffer, observer_.state_);
@ -1266,13 +1254,13 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
rtc::SocketServer* socket_server() const { return vss_.get(); }
webrtc::test::ScopedKeyValueConfig field_trials_;
test::ScopedKeyValueConfig field_trials_;
std::unique_ptr<rtc::VirtualSocketServer> vss_;
rtc::AutoSocketServerThread main_;
rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
cricket::FakePortAllocator* port_allocator_ = nullptr;
FakeRTCCertificateGenerator* fake_certificate_generator_ = nullptr;
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
rtc::scoped_refptr<PeerConnectionInterface> pc_;
MockPeerConnectionObserver observer_;
rtc::scoped_refptr<StreamCollection> reference_collection_;
@ -1392,22 +1380,19 @@ TEST_P(PeerConnectionInterfaceTest,
config.prune_turn_ports = true;
// Create the PC factory and PC with the above config.
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory(
webrtc::CreatePeerConnectionFactory(
rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory(
CreatePeerConnectionFactory(
rtc::Thread::Current(), rtc::Thread::Current(),
rtc::Thread::Current(), fake_audio_capture_module_,
webrtc::CreateBuiltinAudioEncoderFactory(),
webrtc::CreateBuiltinAudioDecoderFactory(),
std::make_unique<webrtc::VideoEncoderFactoryTemplate<
webrtc::LibvpxVp8EncoderTemplateAdapter,
webrtc::LibvpxVp9EncoderTemplateAdapter,
webrtc::OpenH264EncoderTemplateAdapter,
webrtc::LibaomAv1EncoderTemplateAdapter>>(),
std::make_unique<webrtc::VideoDecoderFactoryTemplate<
webrtc::LibvpxVp8DecoderTemplateAdapter,
webrtc::LibvpxVp9DecoderTemplateAdapter,
webrtc::OpenH264DecoderTemplateAdapter,
webrtc::Dav1dDecoderTemplateAdapter>>(),
CreateBuiltinAudioEncoderFactory(),
CreateBuiltinAudioDecoderFactory(),
std::make_unique<VideoEncoderFactoryTemplate<
LibvpxVp8EncoderTemplateAdapter, LibvpxVp9EncoderTemplateAdapter,
OpenH264EncoderTemplateAdapter,
LibaomAv1EncoderTemplateAdapter>>(),
std::make_unique<VideoDecoderFactoryTemplate<
LibvpxVp8DecoderTemplateAdapter, LibvpxVp9DecoderTemplateAdapter,
OpenH264DecoderTemplateAdapter, Dav1dDecoderTemplateAdapter>>(),
nullptr /* audio_mixer */, nullptr /* audio_processing */));
PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.allocator = std::move(port_allocator);
@ -1424,7 +1409,7 @@ TEST_P(PeerConnectionInterfaceTest,
EXPECT_TRUE(raw_port_allocator->flags() & cricket::PORTALLOCATOR_DISABLE_TCP);
EXPECT_TRUE(raw_port_allocator->flags() &
cricket::PORTALLOCATOR_DISABLE_COSTLY_NETWORKS);
EXPECT_EQ(webrtc::PRUNE_BASED_ON_PRIORITY,
EXPECT_EQ(PRUNE_BASED_ON_PRIORITY,
raw_port_allocator->turn_port_prune_policy());
}
@ -1446,8 +1431,7 @@ TEST_P(PeerConnectionInterfaceTest, GetConfigurationAfterCreatePeerConnection) {
TEST_P(PeerConnectionInterfaceTest, GetConfigurationAfterSetConfiguration) {
PeerConnectionInterface::RTCConfiguration starting_config;
starting_config.sdp_semantics = sdp_semantics_;
starting_config.bundle_policy =
webrtc::PeerConnection::kBundlePolicyMaxBundle;
starting_config.bundle_policy = PeerConnection::kBundlePolicyMaxBundle;
CreatePeerConnection(starting_config);
PeerConnectionInterface::RTCConfiguration config = pc_->GetConfiguration();
@ -1978,7 +1962,7 @@ TEST_P(PeerConnectionInterfaceTest, CreateSctpDataChannel) {
RTCConfiguration rtc_config;
CreatePeerConnection(rtc_config);
webrtc::DataChannelInit config;
DataChannelInit config;
auto channel = pc_->CreateDataChannelOrError("1", &config);
EXPECT_TRUE(channel.ok());
EXPECT_TRUE(channel.value()->reliable());
@ -2010,7 +1994,7 @@ TEST_P(PeerConnectionInterfaceTest, CreateSctpDataChannelWhenClosed) {
RTCConfiguration rtc_config;
CreatePeerConnection(rtc_config);
pc_->Close();
webrtc::DataChannelInit config;
DataChannelInit config;
auto ret = pc_->CreateDataChannelOrError("1", &config);
ASSERT_FALSE(ret.ok());
EXPECT_EQ(ret.error().type(), RTCErrorType::INVALID_STATE);
@ -2022,7 +2006,7 @@ TEST_P(PeerConnectionInterfaceTest, CreateSctpDataChannelWithMinusOne) {
RTCConfiguration rtc_config;
CreatePeerConnection(rtc_config);
webrtc::DataChannelInit config;
DataChannelInit config;
config.maxRetransmitTime = -1;
config.maxRetransmits = -1;
auto channel = pc_->CreateDataChannelOrError("1", &config);
@ -2037,7 +2021,7 @@ TEST_P(PeerConnectionInterfaceTest,
CreatePeerConnection(rtc_config);
std::string label = "test";
webrtc::DataChannelInit config;
DataChannelInit config;
config.maxRetransmits = 0;
config.maxRetransmitTime = 0;
@ -2052,7 +2036,7 @@ TEST_P(PeerConnectionInterfaceTest,
RTCConfiguration rtc_config;
CreatePeerConnection(rtc_config);
webrtc::DataChannelInit config;
DataChannelInit config;
config.id = 1;
config.negotiated = true;
@ -2106,7 +2090,7 @@ TEST_P(PeerConnectionInterfaceTest, DISABLED_TestRejectSctpDataChannelInAnswer)
std::string sdp;
EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
CreateSessionDescription(SdpType::kAnswer, sdp));
ASSERT_TRUE(answer);
cricket::ContentInfo* data_info =
cricket::GetFirstDataContent(answer->description());
@ -2125,8 +2109,7 @@ TEST_P(PeerConnectionInterfaceTest, ReceiveFireFoxOffer) {
AddAudioTrack("audio_label");
AddVideoTrack("video_label");
std::unique_ptr<SessionDescriptionInterface> desc(
webrtc::CreateSessionDescription(SdpType::kOffer,
webrtc::kFireFoxSdpOffer, nullptr));
CreateSessionDescription(SdpType::kOffer, kFireFoxSdpOffer, nullptr));
EXPECT_TRUE(DoSetSessionDescription(std::move(desc), false));
CreateAnswerAsLocalDescription();
ASSERT_TRUE(pc_->local_description() != nullptr);
@ -2163,8 +2146,7 @@ TEST_P(PeerConnectionInterfaceTest, DtlsSdesFallbackNotSupported) {
EXPECT_EQ_WAIT(1, fake_certificate_generator_->generated_certificates(),
kTimeout);
std::unique_ptr<SessionDescriptionInterface> desc(
webrtc::CreateSessionDescription(SdpType::kOffer, kDtlsSdesFallbackSdp,
nullptr));
CreateSessionDescription(SdpType::kOffer, kDtlsSdesFallbackSdp, nullptr));
EXPECT_FALSE(DoSetSessionDescription(std::move(desc), /*local=*/false));
}
@ -2177,18 +2159,17 @@ TEST_P(PeerConnectionInterfaceTest, ReceiveUpdatedAudioOfferWithBadCodecs) {
CreateOfferAsLocalDescription();
const char* answer_sdp = (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED
? webrtc::kAudioSdpPlanB
: webrtc::kAudioSdpUnifiedPlan);
? kAudioSdpPlanB
: kAudioSdpUnifiedPlan);
std::unique_ptr<SessionDescriptionInterface> answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, answer_sdp, nullptr));
CreateSessionDescription(SdpType::kAnswer, answer_sdp, nullptr));
EXPECT_TRUE(DoSetSessionDescription(std::move(answer), false));
const char* reoffer_sdp =
(sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED
? webrtc::kAudioSdpWithUnsupportedCodecsPlanB
: webrtc::kAudioSdpWithUnsupportedCodecsUnifiedPlan);
const char* reoffer_sdp = (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED
? kAudioSdpWithUnsupportedCodecsPlanB
: kAudioSdpWithUnsupportedCodecsUnifiedPlan);
std::unique_ptr<SessionDescriptionInterface> updated_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, reoffer_sdp, nullptr));
CreateSessionDescription(SdpType::kOffer, reoffer_sdp, nullptr));
EXPECT_TRUE(DoSetSessionDescription(std::move(updated_offer), false));
CreateAnswerAsLocalDescription();
}
@ -2275,12 +2256,11 @@ TEST_P(PeerConnectionInterfaceTest, SetConfigurationChangesPruneTurnPortsFlag) {
config.prune_turn_ports = false;
CreatePeerConnection(config);
config = pc_->GetConfiguration();
EXPECT_EQ(webrtc::NO_PRUNE, port_allocator_->turn_port_prune_policy());
EXPECT_EQ(NO_PRUNE, port_allocator_->turn_port_prune_policy());
config.prune_turn_ports = true;
EXPECT_TRUE(pc_->SetConfiguration(config).ok());
EXPECT_EQ(webrtc::PRUNE_BASED_ON_PRIORITY,
port_allocator_->turn_port_prune_policy());
EXPECT_EQ(PRUNE_BASED_ON_PRIORITY, port_allocator_->turn_port_prune_policy());
}
// Test that the ice check interval can be changed. This does not verify that
@ -2549,12 +2529,12 @@ TEST_F(PeerConnectionInterfaceTestPlanB, CloseAndTestMethods) {
std::string sdp;
ASSERT_TRUE(pc_->remote_description()->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> remote_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
CreateSessionDescription(SdpType::kOffer, sdp));
EXPECT_FALSE(DoSetRemoteDescription(std::move(remote_offer)));
ASSERT_TRUE(pc_->local_description()->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> local_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
CreateSessionDescription(SdpType::kOffer, sdp));
EXPECT_FALSE(DoSetLocalDescription(std::move(local_offer)));
}
@ -2614,10 +2594,10 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
reference_collection_.get()));
rtc::scoped_refptr<AudioTrackInterface> audio_track2 =
observer_.remote_streams()->at(0)->GetAudioTracks()[1];
EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, audio_track2->state());
EXPECT_EQ(MediaStreamTrackInterface::kLive, audio_track2->state());
rtc::scoped_refptr<VideoTrackInterface> video_track2 =
observer_.remote_streams()->at(0)->GetVideoTracks()[1];
EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, video_track2->state());
EXPECT_EQ(MediaStreamTrackInterface::kLive, video_track2->state());
// Remove the extra audio and video tracks.
std::unique_ptr<SessionDescriptionInterface> desc_ms2 =
@ -2631,10 +2611,10 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
reference_collection_.get()));
// Track state may be updated asynchronously.
EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded,
audio_track2->state(), kTimeout);
EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded,
video_track2->state(), kTimeout);
EXPECT_EQ_WAIT(MediaStreamTrackInterface::kEnded, audio_track2->state(),
kTimeout);
EXPECT_EQ_WAIT(MediaStreamTrackInterface::kEnded, video_track2->state(),
kTimeout);
}
// This tests that remote tracks are ended if a local session description is set
@ -2652,7 +2632,7 @@ TEST_P(PeerConnectionInterfaceTest, RejectMediaContent) {
rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio =
audio_receiver->track();
EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_audio->state());
EXPECT_EQ(MediaStreamTrackInterface::kLive, remote_audio->state());
rtc::scoped_refptr<MediaStreamTrackInterface> remote_video =
video_receiver->track();
EXPECT_EQ(MediaStreamTrackInterface::kLive, remote_video->state());
@ -2696,8 +2676,8 @@ TEST_F(PeerConnectionInterfaceTestPlanB, RemoveTrackThenRejectMediaContent) {
remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]);
std::unique_ptr<SessionDescriptionInterface> local_answer(
webrtc::CreateSessionDescription(SdpType::kAnswer,
GetSdpStringWithStream1(), nullptr));
CreateSessionDescription(SdpType::kAnswer, GetSdpStringWithStream1(),
nullptr));
cricket::ContentInfo* video_info =
local_answer->description()->GetContentByName("video");
video_info->rejected = true;
@ -2986,9 +2966,9 @@ TEST_P(PeerConnectionInterfaceTest,
ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
// Grab a copy of the offer before it gets passed into the PC.
std::unique_ptr<SessionDescriptionInterface> modified_offer =
webrtc::CreateSessionDescription(
webrtc::SdpType::kOffer, offer->session_id(),
offer->session_version(), offer->description()->Clone());
CreateSessionDescription(SdpType::kOffer, offer->session_id(),
offer->session_version(),
offer->description()->Clone());
EXPECT_TRUE(DoSetLocalDescription(std::move(offer)));
auto senders = pc_->GetSenders();
@ -3044,8 +3024,8 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
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<webrtc::MediaStreamInterface> stream_1(
webrtc::MediaStream::Create(kStreams[1]));
rtc::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]);
pc_->AddStream(stream_1.get());
@ -3166,9 +3146,9 @@ TEST_P(PeerConnectionInterfaceTest, SetConfigurationCausingPartialIceRestart) {
EXPECT_TRUE(pc_->SetConfiguration(config).ok());
// Do ICE restart for the first m= section, initiated by remote peer.
std::unique_ptr<webrtc::SessionDescriptionInterface> remote_offer(
webrtc::CreateSessionDescription(SdpType::kOffer,
GetSdpStringWithStream1(), nullptr));
std::unique_ptr<SessionDescriptionInterface> remote_offer(
CreateSessionDescription(SdpType::kOffer, GetSdpStringWithStream1(),
nullptr));
ASSERT_TRUE(remote_offer);
remote_offer->description()->transport_infos()[0].description.ice_ufrag =
"modified";
@ -3214,7 +3194,7 @@ TEST_P(PeerConnectionInterfaceTest, CurrentAndPendingDescriptions) {
// Set remote pranswer.
std::unique_ptr<SessionDescriptionInterface> remote_pranswer(
webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp));
CreateSessionDescription(SdpType::kPrAnswer, sdp));
SessionDescriptionInterface* remote_pranswer_ptr = remote_pranswer.get();
EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_pranswer)));
EXPECT_EQ(local_offer_ptr, pc_->pending_local_description());
@ -3224,7 +3204,7 @@ TEST_P(PeerConnectionInterfaceTest, CurrentAndPendingDescriptions) {
// Set remote answer.
std::unique_ptr<SessionDescriptionInterface> remote_answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
CreateSessionDescription(SdpType::kAnswer, sdp));
SessionDescriptionInterface* remote_answer_ptr = remote_answer.get();
EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_answer)));
EXPECT_EQ(nullptr, pc_->pending_local_description());
@ -3234,7 +3214,7 @@ TEST_P(PeerConnectionInterfaceTest, CurrentAndPendingDescriptions) {
// Set remote offer.
std::unique_ptr<SessionDescriptionInterface> remote_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
CreateSessionDescription(SdpType::kOffer, sdp));
SessionDescriptionInterface* remote_offer_ptr = remote_offer.get();
EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
EXPECT_EQ(remote_offer_ptr, pc_->pending_remote_description());
@ -3244,7 +3224,7 @@ TEST_P(PeerConnectionInterfaceTest, CurrentAndPendingDescriptions) {
// Set local pranswer.
std::unique_ptr<SessionDescriptionInterface> local_pranswer(
webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp));
CreateSessionDescription(SdpType::kPrAnswer, sdp));
SessionDescriptionInterface* local_pranswer_ptr = local_pranswer.get();
EXPECT_TRUE(DoSetLocalDescription(std::move(local_pranswer)));
EXPECT_EQ(remote_offer_ptr, pc_->pending_remote_description());
@ -3254,7 +3234,7 @@ TEST_P(PeerConnectionInterfaceTest, CurrentAndPendingDescriptions) {
// Set local answer.
std::unique_ptr<SessionDescriptionInterface> local_answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
CreateSessionDescription(SdpType::kAnswer, sdp));
SessionDescriptionInterface* local_answer_ptr = local_answer.get();
EXPECT_TRUE(DoSetLocalDescription(std::move(local_answer)));
EXPECT_EQ(nullptr, pc_->pending_remote_description());
@ -3273,9 +3253,8 @@ TEST_P(PeerConnectionInterfaceTest,
// The RtcEventLog will be reset when the PeerConnection is closed.
pc_->Close();
EXPECT_FALSE(
pc_->StartRtcEventLog(std::make_unique<webrtc::RtcEventLogOutputNull>(),
webrtc::RtcEventLog::kImmediateOutput));
EXPECT_FALSE(pc_->StartRtcEventLog(std::make_unique<RtcEventLogOutputNull>(),
RtcEventLog::kImmediateOutput));
pc_->StopRtcEventLog();
}

56
pc/peer_connection_media_unittest.cc
View File

@ -82,9 +82,9 @@ using ::testing::NotNull;
using ::testing::Values;
cricket::MediaSendChannelInterface* SendChannelInternal(
rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
auto transceiver_with_internal = static_cast<rtc::RefCountedObject<
webrtc::RtpTransceiverProxyWithInternal<webrtc::RtpTransceiver>>*>(
rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
auto transceiver_with_internal = static_cast<
rtc::RefCountedObject<RtpTransceiverProxyWithInternal<RtpTransceiver>>*>(
transceiver.get());
auto transceiver_internal =
static_cast<RtpTransceiver*>(transceiver_with_internal->internal());
@ -92,9 +92,9 @@ cricket::MediaSendChannelInterface* SendChannelInternal(
}
cricket::MediaReceiveChannelInterface* ReceiveChannelInternal(
rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
auto transceiver_with_internal = static_cast<rtc::RefCountedObject<
webrtc::RtpTransceiverProxyWithInternal<webrtc::RtpTransceiver>>*>(
rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
auto transceiver_with_internal = static_cast<
rtc::RefCountedObject<RtpTransceiverProxyWithInternal<RtpTransceiver>>*>(
transceiver.get());
auto transceiver_internal =
static_cast<RtpTransceiver*>(transceiver_with_internal->internal());
@ -102,22 +102,22 @@ cricket::MediaReceiveChannelInterface* ReceiveChannelInternal(
}
cricket::FakeVideoMediaSendChannel* VideoMediaSendChannel(
rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
return static_cast<cricket::FakeVideoMediaSendChannel*>(
SendChannelInternal(transceiver));
}
cricket::FakeVideoMediaReceiveChannel* VideoMediaReceiveChannel(
rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
return static_cast<cricket::FakeVideoMediaReceiveChannel*>(
ReceiveChannelInternal(transceiver));
}
cricket::FakeVoiceMediaSendChannel* VoiceMediaSendChannel(
rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
return static_cast<cricket::FakeVoiceMediaSendChannel*>(
SendChannelInternal(transceiver));
}
cricket::FakeVoiceMediaReceiveChannel* VoiceMediaReceiveChannel(
rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
return static_cast<cricket::FakeVoiceMediaReceiveChannel*>(
ReceiveChannelInternal(transceiver));
}
@ -254,7 +254,7 @@ class PeerConnectionMediaBaseTest : public ::testing::Test {
return sdp_semantics_ == SdpSemantics::kUnifiedPlan;
}
webrtc::test::ScopedKeyValueConfig field_trials_;
test::ScopedKeyValueConfig field_trials_;
std::unique_ptr<rtc::VirtualSocketServer> vss_;
rtc::AutoSocketServerThread main_;
const SdpSemantics sdp_semantics_;
@ -1495,10 +1495,10 @@ TEST_P(PeerConnectionMediaTest, RedFmtpPayloadDifferentRedundancy) {
}
template <typename C>
bool CompareCodecs(const std::vector<webrtc::RtpCodecCapability>& capabilities,
bool CompareCodecs(const std::vector<RtpCodecCapability>& capabilities,
const std::vector<C>& codecs) {
bool capability_has_rtx =
absl::c_any_of(capabilities, [](const webrtc::RtpCodecCapability& codec) {
absl::c_any_of(capabilities, [](const RtpCodecCapability& codec) {
return codec.name == cricket::kRtxCodecName;
});
bool codecs_has_rtx = absl::c_any_of(codecs, [](const C& codec) {
@ -1510,16 +1510,16 @@ bool CompareCodecs(const std::vector<webrtc::RtpCodecCapability>& capabilities,
codecs, std::back_inserter(codecs_no_rtx),
[](const C& codec) { return codec.name != cricket::kRtxCodecName; });
std::vector<webrtc::RtpCodecCapability> capabilities_no_rtx;
std::vector<RtpCodecCapability> capabilities_no_rtx;
absl::c_copy_if(capabilities, std::back_inserter(capabilities_no_rtx),
[](const webrtc::RtpCodecCapability& codec) {
[](const RtpCodecCapability& codec) {
return codec.name != cricket::kRtxCodecName;
});
return capability_has_rtx == codecs_has_rtx &&
absl::c_equal(
capabilities_no_rtx, codecs_no_rtx,
[](const webrtc::RtpCodecCapability& capability, const C& codec) {
[](const RtpCodecCapability& capability, const C& codec) {
return codec.MatchesRtpCodec(capability);
});
}
@ -1538,9 +1538,9 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
auto capabilities = caller->pc_factory()->GetRtpSenderCapabilities(
cricket::MediaType::MEDIA_TYPE_AUDIO);
std::vector<webrtc::RtpCodecCapability> codecs;
std::vector<RtpCodecCapability> codecs;
absl::c_copy_if(capabilities.codecs, std::back_inserter(codecs),
[](const webrtc::RtpCodecCapability& codec) {
[](const RtpCodecCapability& codec) {
return codec.name.find("_only_") != std::string::npos;
});
@ -1561,9 +1561,9 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
auto capabilities = caller->pc_factory()->GetRtpReceiverCapabilities(
cricket::MediaType::MEDIA_TYPE_AUDIO);
std::vector<webrtc::RtpCodecCapability> codecs;
std::vector<RtpCodecCapability> codecs;
absl::c_copy_if(capabilities.codecs, std::back_inserter(codecs),
[](const webrtc::RtpCodecCapability& codec) {
[](const RtpCodecCapability& codec) {
return codec.name.find("_only_") != std::string::npos;
});
@ -1611,7 +1611,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
auto codecs_only_rtx_red_fec = codecs;
auto it = std::remove_if(codecs_only_rtx_red_fec.begin(),
codecs_only_rtx_red_fec.end(),
[](const webrtc::RtpCodecCapability& codec) {
[](const RtpCodecCapability& codec) {
return !(codec.name == cricket::kRtxCodecName ||
codec.name == cricket::kRedCodecName ||
codec.name == cricket::kUlpfecCodecName);
@ -1651,7 +1651,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
caller->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
.codecs;
std::vector<webrtc::RtpCodecCapability> empty_codecs = {};
std::vector<RtpCodecCapability> empty_codecs = {};
auto audio_transceiver = caller->pc()->GetTransceivers().front();
@ -1706,7 +1706,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
auto codecs_only_rtx_red_fec = codecs;
auto it = std::remove_if(codecs_only_rtx_red_fec.begin(),
codecs_only_rtx_red_fec.end(),
[](const webrtc::RtpCodecCapability& codec) {
[](const RtpCodecCapability& codec) {
return !(codec.name == cricket::kRtxCodecName ||
codec.name == cricket::kRedCodecName ||
codec.name == cricket::kUlpfecCodecName);
@ -1747,7 +1747,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO)
.codecs;
std::vector<webrtc::RtpCodecCapability> empty_codecs = {};
std::vector<RtpCodecCapability> empty_codecs = {};
auto video_transceiver = caller->pc()->GetTransceivers().front();
@ -1817,7 +1817,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan, SetCodecPreferencesVideoWithRtx) {
auto video_codecs_vpx_rtx = sender_video_codecs;
auto it =
std::remove_if(video_codecs_vpx_rtx.begin(), video_codecs_vpx_rtx.end(),
[](const webrtc::RtpCodecCapability& codec) {
[](const RtpCodecCapability& codec) {
return codec.name != cricket::kRtxCodecName &&
codec.name != cricket::kVp8CodecName &&
codec.name != cricket::kVp9CodecName;
@ -1866,7 +1866,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
auto video_codecs_vpx = video_codecs;
auto it = std::remove_if(video_codecs_vpx.begin(), video_codecs_vpx.end(),
[](const webrtc::RtpCodecCapability& codec) {
[](const RtpCodecCapability& codec) {
return codec.name != cricket::kVp8CodecName &&
codec.name != cricket::kVp9CodecName;
});
@ -1889,7 +1889,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
auto recv_transceiver = callee->pc()->GetTransceivers().front();
auto video_codecs_vp8_rtx = video_codecs;
it = std::remove_if(video_codecs_vp8_rtx.begin(), video_codecs_vp8_rtx.end(),
[](const webrtc::RtpCodecCapability& codec) {
[](const RtpCodecCapability& codec) {
bool r = codec.name != cricket::kVp8CodecName &&
codec.name != cricket::kRtxCodecName;
return r;
@ -1936,7 +1936,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
auto video_codecs_vpx = video_codecs;
auto it = std::remove_if(video_codecs_vpx.begin(), video_codecs_vpx.end(),
[](const webrtc::RtpCodecCapability& codec) {
[](const RtpCodecCapability& codec) {
return codec.name != cricket::kVp8CodecName &&
codec.name != cricket::kVp9CodecName;
});

2
pc/peer_connection_rampup_tests.cc
View File

@ -201,7 +201,7 @@ class PeerConnectionRampUpTest : public ::testing::Test {
fake_network_managers_.emplace_back(fake_network_manager);
auto observer = std::make_unique<MockPeerConnectionObserver>();
webrtc::PeerConnectionDependencies dependencies(observer.get());
PeerConnectionDependencies dependencies(observer.get());
cricket::BasicPortAllocator* port_allocator =
new cricket::BasicPortAllocator(fake_network_manager,
firewall_socket_factory_.get());

14
pc/peer_connection_rtp_unittest.cc
View File

@ -75,13 +75,13 @@ using ::testing::UnorderedElementsAre;
using ::testing::Values;
template <typename MethodFunctor>
class OnSuccessObserver : public webrtc::SetRemoteDescriptionObserverInterface {
class OnSuccessObserver : public SetRemoteDescriptionObserverInterface {
public:
explicit OnSuccessObserver(MethodFunctor on_success)
: on_success_(std::move(on_success)) {}
// webrtc::SetRemoteDescriptionObserverInterface implementation.
void OnSetRemoteDescriptionComplete(webrtc::RTCError error) override {
// SetRemoteDescriptionObserverInterface implementation.
void OnSetRemoteDescriptionComplete(RTCError error) override {
RTC_CHECK(error.ok());
on_success_();
}
@ -113,7 +113,7 @@ class PeerConnectionRtpBaseTest : public ::testing::Test {
Dav1dDecoderTemplateAdapter>>(),
nullptr /* audio_mixer */,
nullptr /* audio_processing */)) {
webrtc::metrics::Reset();
metrics::Reset();
}
std::unique_ptr<PeerConnectionWrapper> CreatePeerConnection() {
@ -201,7 +201,7 @@ class PeerConnectionRtpTestUnifiedPlan : public PeerConnectionRtpBaseTest {
}
};
// These tests cover `webrtc::PeerConnectionObserver` callbacks firing upon
// These tests cover `PeerConnectionObserver` callbacks firing upon
// setting the remote description.
TEST_P(PeerConnectionRtpTest, AddTrackWithoutStreamFiresOnAddTrack) {
@ -934,8 +934,8 @@ TEST_P(PeerConnectionRtpTest,
auto caller = CreatePeerConnection();
auto callee = CreatePeerConnection();
rtc::scoped_refptr<webrtc::MockSetSessionDescriptionObserver> observer =
rtc::make_ref_counted<webrtc::MockSetSessionDescriptionObserver>();
rtc::scoped_refptr<MockSetSessionDescriptionObserver> observer =
rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
auto offer = caller->CreateOfferAndSetAsLocal();
callee->pc()->SetRemoteDescription(observer.get(), offer.release());

20
pc/peer_connection_signaling_unittest.cc
View File

@ -896,8 +896,8 @@ TEST_P(PeerConnectionSignalingTest, UnsupportedContentType) {
"m=bogus 9 FOO 0 8\r\n"
"c=IN IP4 0.0.0.0\r\n"
"a=mid:bogusmid\r\n";
std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description =
webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
std::unique_ptr<SessionDescriptionInterface> remote_description =
CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
EXPECT_TRUE(caller->SetRemoteDescription(std::move(remote_description)));
@ -977,8 +977,8 @@ TEST_P(PeerConnectionSignalingTest, ReceiveFlexFec) {
"a=ssrc-group:FEC-FR 1224551896 1953032773\r\n"
"a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n"
"a=ssrc:1953032773 cname:/exJcmhSLpyu9FgV\r\n";
std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description =
webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
std::unique_ptr<SessionDescriptionInterface> remote_description =
CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
EXPECT_TRUE(caller->SetRemoteDescription(std::move(remote_description)));
@ -1033,8 +1033,8 @@ TEST_P(PeerConnectionSignalingTest, ReceiveFlexFecReoffer) {
"a=ssrc-group:FEC-FR 1224551896 1953032773\r\n"
"a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n"
"a=ssrc:1953032773 cname:/exJcmhSLpyu9FgV\r\n";
std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description =
webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
std::unique_ptr<SessionDescriptionInterface> remote_description =
CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
EXPECT_TRUE(caller->SetRemoteDescription(std::move(remote_description)));
@ -1104,8 +1104,8 @@ TEST_P(PeerConnectionSignalingTest, MidAttributeMaxLength) {
"a=rtcp-fb:102 nack\r\n"
"a=rtcp-fb:102 nack pli\r\n"
"a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n";
std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description =
webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
std::unique_ptr<SessionDescriptionInterface> remote_description =
CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
EXPECT_FALSE(caller->SetRemoteDescription(std::move(remote_description)));
}
@ -1339,8 +1339,8 @@ TEST_F(PeerConnectionSignalingUnifiedPlanTest, RtxReofferApt) {
"a=rtcp-fb:102 nack\r\n"
"a=rtcp-fb:102 nack pli\r\n"
"a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n";
std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description =
webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
std::unique_ptr<SessionDescriptionInterface> remote_description =
CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
EXPECT_TRUE(callee->SetRemoteDescription(std::move(remote_description)));

2
pc/peer_connection_simulcast_unittest.cc
View File

@ -220,7 +220,7 @@ class PeerConnectionSimulcastMetricsTests
: public PeerConnectionSimulcastTests,
public ::testing::WithParamInterface<int> {
protected:
PeerConnectionSimulcastMetricsTests() { webrtc::metrics::Reset(); }
PeerConnectionSimulcastMetricsTests() { metrics::Reset(); }
};
#endif

77
pc/peer_connection_svc_integrationtest.cc
View File

@ -37,14 +37,13 @@ class PeerConnectionSVCIntegrationTest
: PeerConnectionIntegrationBaseTest(SdpSemantics::kUnifiedPlan) {}
RTCError SetCodecPreferences(
rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver,
rtc::scoped_refptr<RtpTransceiverInterface> transceiver,
absl::string_view codec_name) {
webrtc::RtpCapabilities capabilities =
RtpCapabilities capabilities =
caller()->pc_factory()->GetRtpSenderCapabilities(
cricket::MEDIA_TYPE_VIDEO);
std::vector<RtpCodecCapability> codecs;
for (const webrtc::RtpCodecCapability& codec_capability :
capabilities.codecs) {
for (const RtpCodecCapability& codec_capability : capabilities.codecs) {
if (codec_capability.name == codec_name)
codecs.push_back(codec_capability);
}
@ -55,8 +54,8 @@ class PeerConnectionSVCIntegrationTest
TEST_F(PeerConnectionSVCIntegrationTest, AddTransceiverAcceptsL1T1) {
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
webrtc::RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
RtpEncodingParameters encoding_parameters;
encoding_parameters.scalability_mode = "L1T1";
init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error =
@ -67,8 +66,8 @@ TEST_F(PeerConnectionSVCIntegrationTest, AddTransceiverAcceptsL1T1) {
TEST_F(PeerConnectionSVCIntegrationTest, AddTransceiverAcceptsL3T3) {
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
webrtc::RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
RtpEncodingParameters encoding_parameters;
encoding_parameters.scalability_mode = "L3T3";
init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error =
@ -80,33 +79,32 @@ TEST_F(PeerConnectionSVCIntegrationTest,
AddTransceiverRejectsUnknownScalabilityMode) {
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
webrtc::RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
RtpEncodingParameters encoding_parameters;
encoding_parameters.scalability_mode = "FOOBAR";
init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
EXPECT_FALSE(transceiver_or_error.ok());
EXPECT_EQ(transceiver_or_error.error().type(),
webrtc::RTCErrorType::UNSUPPORTED_OPERATION);
RTCErrorType::UNSUPPORTED_OPERATION);
}
TEST_F(PeerConnectionSVCIntegrationTest, SetParametersAcceptsL1T3WithVP8) {
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
webrtc::RtpCapabilities capabilities =
RtpCapabilities capabilities =
caller()->pc_factory()->GetRtpSenderCapabilities(
cricket::MEDIA_TYPE_VIDEO);
std::vector<RtpCodecCapability> vp8_codec;
for (const webrtc::RtpCodecCapability& codec_capability :
capabilities.codecs) {
for (const RtpCodecCapability& codec_capability : capabilities.codecs) {
if (codec_capability.name == cricket::kVp8CodecName)
vp8_codec.push_back(codec_capability);
}
webrtc::RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
RtpEncodingParameters encoding_parameters;
init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@ -114,7 +112,7 @@ TEST_F(PeerConnectionSVCIntegrationTest, SetParametersAcceptsL1T3WithVP8) {
auto transceiver = transceiver_or_error.MoveValue();
EXPECT_TRUE(transceiver->SetCodecPreferences(vp8_codec).ok());
webrtc::RtpParameters parameters = transceiver->sender()->GetParameters();
RtpParameters parameters = transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L1T3";
auto result = transceiver->sender()->SetParameters(parameters);
@ -125,8 +123,8 @@ TEST_F(PeerConnectionSVCIntegrationTest, SetParametersRejectsL3T3WithVP8) {
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
webrtc::RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
RtpEncodingParameters encoding_parameters;
init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@ -134,12 +132,12 @@ TEST_F(PeerConnectionSVCIntegrationTest, SetParametersRejectsL3T3WithVP8) {
auto transceiver = transceiver_or_error.MoveValue();
EXPECT_TRUE(SetCodecPreferences(transceiver, cricket::kVp8CodecName).ok());
webrtc::RtpParameters parameters = transceiver->sender()->GetParameters();
RtpParameters parameters = transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L3T3";
auto result = transceiver->sender()->SetParameters(parameters);
EXPECT_FALSE(result.ok());
EXPECT_EQ(result.type(), webrtc::RTCErrorType::INVALID_MODIFICATION);
EXPECT_EQ(result.type(), RTCErrorType::INVALID_MODIFICATION);
}
TEST_F(PeerConnectionSVCIntegrationTest,
@ -147,8 +145,8 @@ TEST_F(PeerConnectionSVCIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
webrtc::RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
RtpEncodingParameters encoding_parameters;
init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@ -159,7 +157,7 @@ TEST_F(PeerConnectionSVCIntegrationTest,
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
webrtc::RtpParameters parameters = transceiver->sender()->GetParameters();
RtpParameters parameters = transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L1T3";
auto result = transceiver->sender()->SetParameters(parameters);
@ -171,8 +169,8 @@ TEST_F(PeerConnectionSVCIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
webrtc::RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
RtpEncodingParameters encoding_parameters;
init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@ -183,7 +181,7 @@ TEST_F(PeerConnectionSVCIntegrationTest,
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
webrtc::RtpParameters parameters = transceiver->sender()->GetParameters();
RtpParameters parameters = transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L3T3";
auto result = transceiver->sender()->SetParameters(parameters);
@ -195,8 +193,8 @@ TEST_F(PeerConnectionSVCIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
webrtc::RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
RtpEncodingParameters encoding_parameters;
init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@ -207,12 +205,12 @@ TEST_F(PeerConnectionSVCIntegrationTest,
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
webrtc::RtpParameters parameters = transceiver->sender()->GetParameters();
RtpParameters parameters = transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L3T3";
auto result = transceiver->sender()->SetParameters(parameters);
EXPECT_FALSE(result.ok());
EXPECT_EQ(result.type(), webrtc::RTCErrorType::INVALID_MODIFICATION);
EXPECT_EQ(result.type(), RTCErrorType::INVALID_MODIFICATION);
}
TEST_F(PeerConnectionSVCIntegrationTest,
@ -220,8 +218,8 @@ TEST_F(PeerConnectionSVCIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
webrtc::RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
RtpEncodingParameters encoding_parameters;
init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@ -232,27 +230,27 @@ TEST_F(PeerConnectionSVCIntegrationTest,
caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
webrtc::RtpParameters parameters = transceiver->sender()->GetParameters();
RtpParameters parameters = transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "FOOBAR";
auto result = transceiver->sender()->SetParameters(parameters);
EXPECT_FALSE(result.ok());
EXPECT_EQ(result.type(), webrtc::RTCErrorType::INVALID_MODIFICATION);
EXPECT_EQ(result.type(), RTCErrorType::INVALID_MODIFICATION);
}
TEST_F(PeerConnectionSVCIntegrationTest, FallbackToL1Tx) {
ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling();
webrtc::RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters;
RtpTransceiverInit init;
RtpEncodingParameters encoding_parameters;
init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
ASSERT_TRUE(transceiver_or_error.ok());
auto caller_transceiver = transceiver_or_error.MoveValue();
webrtc::RtpCapabilities capabilities =
RtpCapabilities capabilities =
caller()->pc_factory()->GetRtpSenderCapabilities(
cricket::MEDIA_TYPE_VIDEO);
std::vector<RtpCodecCapability> send_codecs = capabilities.codecs;
@ -267,8 +265,7 @@ TEST_F(PeerConnectionSVCIntegrationTest, FallbackToL1Tx) {
caller_transceiver->SetCodecPreferences(send_codecs);
// L3T3 should be supported by VP9
webrtc::RtpParameters parameters =
caller_transceiver->sender()->GetParameters();
RtpParameters parameters = caller_transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L3T3";
auto result = caller_transceiver->sender()->SetParameters(parameters);

3
pc/peer_connection_wrapper.cc
View File

@ -339,8 +339,7 @@ bool PeerConnectionWrapper::IsIceConnected() {
return observer()->ice_connected_;
}
rtc::scoped_refptr<const webrtc::RTCStatsReport>
PeerConnectionWrapper::GetStats() {
rtc::scoped_refptr<const RTCStatsReport> PeerConnectionWrapper::GetStats() {
auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>();
pc()->GetStats(callback.get());
EXPECT_TRUE_WAIT(callback->called(), kDefaultTimeout);

4
pc/rtc_stats_collector.cc
View File

@ -336,7 +336,7 @@ const char* QualityLimitationReasonToRTCQualityLimitationReason(
std::map<std::string, double>
QualityLimitationDurationToRTCQualityLimitationDuration(
std::map<webrtc::QualityLimitationReason, int64_t> durations_ms) {
std::map<QualityLimitationReason, int64_t> durations_ms) {
std::map<std::string, double> result;
// The internal duration is defined in milliseconds while the spec defines
// the value in seconds:
@ -513,7 +513,7 @@ std::unique_ptr<RTCInboundRtpStreamStats> CreateInboundAudioStreamStats(
std::unique_ptr<RTCAudioPlayoutStats> CreateAudioPlayoutStats(
const AudioDeviceModule::Stats& audio_device_stats,
webrtc::Timestamp timestamp) {
Timestamp timestamp) {
auto stats = std::make_unique<RTCAudioPlayoutStats>(
/*id=*/kAudioPlayoutSingletonId, timestamp);
stats->synthesized_samples_duration =

2
pc/rtc_stats_collector.h
View File

@ -317,7 +317,7 @@ class RTCStatsCollector : public rtc::RefCountInterface {
uint32_t data_channels_closed;
// Identifies channels that have been opened, whose internal id is stored in
// the set until they have been fully closed.
webrtc::flat_set<int> opened_data_channels;
flat_set<int> opened_data_channels;
};
InternalRecord internal_record_;
};

25
pc/rtc_stats_collector_unittest.cc
View File

@ -263,9 +263,9 @@ class FakeAudioTrackForStats : public MediaStreamTrack<AudioTrackInterface> {
std::string kind() const override {
return MediaStreamTrackInterface::kAudioKind;
}
webrtc::AudioSourceInterface* GetSource() const override { return nullptr; }
void AddSink(webrtc::AudioTrackSinkInterface* sink) override {}
void RemoveSink(webrtc::AudioTrackSinkInterface* sink) override {}
AudioSourceInterface* GetSource() const override { return nullptr; }
void AddSink(AudioTrackSinkInterface* sink) override {}
void RemoveSink(AudioTrackSinkInterface* sink) override {}
bool GetSignalLevel(int* level) override { return false; }
rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
return processor_;
@ -2030,7 +2030,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidatePairStats) {
EXPECT_TRUE(report->Get(*expected_pair.transport_id));
// Set bandwidth and "GetStats" again.
webrtc::Call::Stats call_stats;
Call::Stats call_stats;
const int kSendBandwidth = 888;
call_stats.send_bandwidth_bps = kSendBandwidth;
const int kRecvBandwidth = 999;
@ -2339,12 +2339,9 @@ TEST_F(RTCStatsCollectorTest, CollectRTCInboundRtpStreamStats_Video) {
video_media_info.receivers[0].key_frames_decoded = 3;
video_media_info.receivers[0].frames_dropped = 13;
video_media_info.receivers[0].qp_sum = absl::nullopt;
video_media_info.receivers[0].total_decode_time =
webrtc::TimeDelta::Seconds(9);
video_media_info.receivers[0].total_processing_delay =
webrtc::TimeDelta::Millis(600);
video_media_info.receivers[0].total_assembly_time =
webrtc::TimeDelta::Millis(500);
video_media_info.receivers[0].total_decode_time = TimeDelta::Seconds(9);
video_media_info.receivers[0].total_processing_delay = TimeDelta::Millis(600);
video_media_info.receivers[0].total_assembly_time = TimeDelta::Millis(500);
video_media_info.receivers[0].frames_assembled_from_multiple_packets = 23;
video_media_info.receivers[0].total_inter_frame_delay = 0.123;
video_media_info.receivers[0].total_squared_inter_frame_delay = 0.00456;
@ -2617,12 +2614,12 @@ TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRtpStreamStats_Video) {
video_media_info.senders[0].key_frames_encoded = 3;
video_media_info.senders[0].total_encode_time_ms = 9000;
video_media_info.senders[0].total_encoded_bytes_target = 1234;
video_media_info.senders[0].total_packet_send_delay =
webrtc::TimeDelta::Seconds(10);
video_media_info.senders[0].total_packet_send_delay = TimeDelta::Seconds(10);
video_media_info.senders[0].quality_limitation_reason =
QualityLimitationReason::kBandwidth;
video_media_info.senders[0].quality_limitation_durations_ms
[webrtc::QualityLimitationReason::kBandwidth] = 300;
video_media_info.senders[0]
.quality_limitation_durations_ms[QualityLimitationReason::kBandwidth] =
300;
video_media_info.senders[0].quality_limitation_resolution_changes = 56u;
video_media_info.senders[0].qp_sum = absl::nullopt;
video_media_info.senders[0].content_type = VideoContentType::UNSPECIFIED;

2
pc/rtc_stats_traversal_unittest.cc
View File

@ -47,7 +47,7 @@ class RTCStatsTraversalTest : public ::testing::Test {
for (const RTCStats* start_node : start_nodes) {
start_ids.push_back(start_node->id());
}
result_ = webrtc::TakeReferencedStats(initial_report_, start_ids);
result_ = ::webrtc::TakeReferencedStats(initial_report_, start_ids);
}
void EXPECT_VISITED(const RTCStats* stats) {

16
pc/rtp_sender.cc
View File

@ -115,13 +115,13 @@ class SignalingThreadCallback {
if (!signaling_thread_->IsCurrent()) {
signaling_thread_->PostTask(
[callback = std::move(callback_), error]() mutable {
webrtc::InvokeSetParametersCallback(callback, error);
InvokeSetParametersCallback(callback, error);
});
callback_ = nullptr;
return;
}
webrtc::InvokeSetParametersCallback(callback_, error);
InvokeSetParametersCallback(callback_, error);
callback_ = nullptr;
}
@ -243,7 +243,7 @@ void RtpSenderBase::SetParametersInternal(const RtpParameters& parameters,
"Attempted to set an unimplemented parameter of RtpParameters.");
RTC_LOG(LS_ERROR) << error.message() << " ("
<< ::webrtc::ToString(error.type()) << ")";
webrtc::InvokeSetParametersCallback(callback, error);
InvokeSetParametersCallback(callback, error);
return;
}
if (!media_channel_ || !ssrc_) {
@ -252,7 +252,7 @@ void RtpSenderBase::SetParametersInternal(const RtpParameters& parameters,
if (result.ok()) {
init_parameters_ = parameters;
}
webrtc::InvokeSetParametersCallback(callback, result);
InvokeSetParametersCallback(callback, result);
return;
}
auto task = [&, callback = std::move(callback),
@ -268,13 +268,13 @@ void RtpSenderBase::SetParametersInternal(const RtpParameters& parameters,
RTCError result = cricket::CheckRtpParametersInvalidModificationAndValues(
old_parameters, rtp_parameters);
if (!result.ok()) {
webrtc::InvokeSetParametersCallback(callback, result);
InvokeSetParametersCallback(callback, result);
return;
}
result = CheckCodecParameters(rtp_parameters);
if (!result.ok()) {
webrtc::InvokeSetParametersCallback(callback, result);
InvokeSetParametersCallback(callback, result);
return;
}
@ -389,7 +389,7 @@ void RtpSenderBase::SetParametersAsync(const RtpParameters& parameters,
TRACE_EVENT0("webrtc", "RtpSenderBase::SetParametersAsync");
RTCError result = CheckSetParameters(parameters);
if (!result.ok()) {
webrtc::InvokeSetParametersCallback(callback, result);
InvokeSetParametersCallback(callback, result);
return;
}
@ -399,7 +399,7 @@ void RtpSenderBase::SetParametersAsync(const RtpParameters& parameters,
signaling_thread_,
[this, callback = std::move(callback)](RTCError error) mutable {
last_transaction_id_.reset();
webrtc::InvokeSetParametersCallback(callback, error);
InvokeSetParametersCallback(callback, error);
}),
false);
}

2
pc/rtp_sender.h
View File

@ -87,7 +87,7 @@ class RtpSenderInternal : public RtpSenderInterface {
// Additional checks that are specific to the current codec settings
virtual RTCError CheckCodecParameters(const RtpParameters& parameters) {
return webrtc::RTCError::OK();
return RTCError::OK();
}
// Returns an ID that changes every time SetTrack() is called, but

80
pc/rtp_sender_receiver_unittest.cc
View File

@ -105,7 +105,7 @@ class RtpSenderReceiverTest
: network_thread_(rtc::Thread::Current()),
worker_thread_(rtc::Thread::Current()),
video_bitrate_allocator_factory_(
webrtc::CreateBuiltinVideoBitrateAllocatorFactory()),
CreateBuiltinVideoBitrateAllocatorFactory()),
// Create fake media engine/etc. so we can create channels to use to
// test RtpSenders/RtpReceivers.
media_engine_(std::make_unique<cricket::FakeMediaEngine>()),
@ -119,16 +119,16 @@ class RtpSenderReceiverTest
// Fake media channels are owned by the media engine.
voice_media_send_channel_ = media_engine_->voice().CreateSendChannel(
&fake_call_, cricket::MediaConfig(), cricket::AudioOptions(),
webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create());
CryptoOptions(), AudioCodecPairId::Create());
video_media_send_channel_ = media_engine_->video().CreateSendChannel(
&fake_call_, cricket::MediaConfig(), cricket::VideoOptions(),
webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get());
CryptoOptions(), video_bitrate_allocator_factory_.get());
voice_media_receive_channel_ = media_engine_->voice().CreateReceiveChannel(
&fake_call_, cricket::MediaConfig(), cricket::AudioOptions(),
webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create());
CryptoOptions(), AudioCodecPairId::Create());
video_media_receive_channel_ = media_engine_->video().CreateReceiveChannel(
&fake_call_, cricket::MediaConfig(), cricket::VideoOptions(),
webrtc::CryptoOptions());
CryptoOptions());
// Create streams for predefined SSRCs. Streams need to exist in order
// for the senders and receievers to apply parameters to them.
@ -162,8 +162,8 @@ class RtpSenderReceiverTest
audio_track_ = nullptr;
}
std::unique_ptr<webrtc::RtpTransportInternal> CreateDtlsSrtpTransport() {
auto dtls_srtp_transport = std::make_unique<webrtc::DtlsSrtpTransport>(
std::unique_ptr<RtpTransportInternal> CreateDtlsSrtpTransport() {
auto dtls_srtp_transport = std::make_unique<DtlsSrtpTransport>(
/*rtcp_mux_required=*/true, field_trials_);
dtls_srtp_transport->SetDtlsTransports(rtp_dtls_transport_.get(),
/*rtcp_dtls_transport=*/nullptr);
@ -515,12 +515,12 @@ class RtpSenderReceiverTest
test::RunLoop run_loop_;
rtc::Thread* const network_thread_;
rtc::Thread* const worker_thread_;
webrtc::RtcEventLogNull event_log_;
RtcEventLogNull event_log_;
// The `rtp_dtls_transport_` and `rtp_transport_` should be destroyed after
// the `channel_manager`.
std::unique_ptr<cricket::DtlsTransportInternal> rtp_dtls_transport_;
std::unique_ptr<webrtc::RtpTransportInternal> rtp_transport_;
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
std::unique_ptr<RtpTransportInternal> rtp_transport_;
std::unique_ptr<VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory_;
std::unique_ptr<cricket::FakeMediaEngine> media_engine_;
rtc::UniqueRandomIdGenerator ssrc_generator_;
@ -540,7 +540,7 @@ class RtpSenderReceiverTest
rtc::scoped_refptr<MediaStreamInterface> local_stream_;
rtc::scoped_refptr<VideoTrackInterface> video_track_;
rtc::scoped_refptr<AudioTrackInterface> audio_track_;
webrtc::test::ScopedKeyValueConfig field_trials_;
test::ScopedKeyValueConfig field_trials_;
};
// Test that `voice_channel_` is updated when an audio track is associated
@ -651,15 +651,13 @@ TEST_F(RtpSenderReceiverTest, LocalVideoTrackDisable) {
TEST_F(RtpSenderReceiverTest, RemoteVideoTrackState) {
CreateVideoRtpReceiver();
EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, video_track_->state());
EXPECT_EQ(webrtc::MediaSourceInterface::kLive,
video_track_->GetSource()->state());
EXPECT_EQ(MediaStreamTrackInterface::kLive, video_track_->state());
EXPECT_EQ(MediaSourceInterface::kLive, video_track_->GetSource()->state());
DestroyVideoRtpReceiver();
EXPECT_EQ(webrtc::MediaStreamTrackInterface::kEnded, video_track_->state());
EXPECT_EQ(webrtc::MediaSourceInterface::kEnded,
video_track_->GetSource()->state());
EXPECT_EQ(MediaStreamTrackInterface::kEnded, video_track_->state());
EXPECT_EQ(MediaSourceInterface::kEnded, video_track_->GetSource()->state());
DestroyVideoRtpReceiver();
}
@ -888,9 +886,9 @@ TEST_F(RtpSenderReceiverTest, AudioSenderCanSetParametersAsync) {
RtpParameters params = audio_rtp_sender_->GetParameters();
EXPECT_EQ(1u, params.encodings.size());
absl::optional<webrtc::RTCError> result;
absl::optional<RTCError> result;
audio_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; });
params, [&result](RTCError error) { result = error; });
run_loop_.Flush();
EXPECT_TRUE(result->ok());
@ -918,13 +916,13 @@ TEST_F(RtpSenderReceiverTest,
audio_rtp_sender_ =
AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr, nullptr);
absl::optional<webrtc::RTCError> result;
absl::optional<RTCError> result;
RtpParameters params = audio_rtp_sender_->GetParameters();
ASSERT_EQ(1u, params.encodings.size());
params.encodings[0].max_bitrate_bps = 90000;
audio_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; });
params, [&result](RTCError error) { result = error; });
run_loop_.Flush();
EXPECT_TRUE(result->ok());
@ -932,7 +930,7 @@ TEST_F(RtpSenderReceiverTest,
EXPECT_EQ(params.encodings[0].max_bitrate_bps, 90000);
audio_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; });
params, [&result](RTCError error) { result = error; });
run_loop_.Flush();
EXPECT_TRUE(result->ok());
@ -1016,13 +1014,13 @@ TEST_F(RtpSenderReceiverTest,
RtpParameters params = audio_rtp_sender_->GetParameters();
EXPECT_EQ(1u, params.encodings.size());
absl::optional<webrtc::RTCError> result;
absl::optional<RTCError> result;
audio_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; });
params, [&result](RTCError error) { result = error; });
run_loop_.Flush();
EXPECT_TRUE(result->ok());
audio_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; });
params, [&result](RTCError error) { result = error; });
run_loop_.Flush();
EXPECT_EQ(RTCErrorType::INVALID_STATE, result->type());
@ -1081,7 +1079,7 @@ TEST_F(RtpSenderReceiverTest, SetAudioMaxSendBitrate) {
CreateAudioRtpSender();
EXPECT_EQ(-1, voice_media_send_channel()->max_bps());
webrtc::RtpParameters params = audio_rtp_sender_->GetParameters();
RtpParameters params = audio_rtp_sender_->GetParameters();
EXPECT_EQ(1U, params.encodings.size());
EXPECT_FALSE(params.encodings[0].max_bitrate_bps);
params.encodings[0].max_bitrate_bps = 1000;
@ -1106,10 +1104,9 @@ TEST_F(RtpSenderReceiverTest, SetAudioMaxSendBitrate) {
TEST_F(RtpSenderReceiverTest, SetAudioBitratePriority) {
CreateAudioRtpSender();
webrtc::RtpParameters params = audio_rtp_sender_->GetParameters();
RtpParameters params = audio_rtp_sender_->GetParameters();
EXPECT_EQ(1U, params.encodings.size());
EXPECT_EQ(webrtc::kDefaultBitratePriority,
params.encodings[0].bitrate_priority);
EXPECT_EQ(kDefaultBitratePriority, params.encodings[0].bitrate_priority);
double new_bitrate_priority = 2.0;
params.encodings[0].bitrate_priority = new_bitrate_priority;
EXPECT_TRUE(audio_rtp_sender_->SetParameters(params).ok());
@ -1140,9 +1137,9 @@ TEST_F(RtpSenderReceiverTest, VideoSenderCanSetParametersAsync) {
RtpParameters params = video_rtp_sender_->GetParameters();
EXPECT_EQ(1u, params.encodings.size());
absl::optional<webrtc::RTCError> result;
absl::optional<RTCError> result;
video_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; });
params, [&result](RTCError error) { result = error; });
run_loop_.Flush();
EXPECT_TRUE(result->ok());
@ -1170,19 +1167,19 @@ TEST_F(RtpSenderReceiverTest,
video_rtp_sender_ =
VideoRtpSender::Create(worker_thread_, /*id=*/"", nullptr);
absl::optional<webrtc::RTCError> result;
absl::optional<RTCError> result;
RtpParameters params = video_rtp_sender_->GetParameters();
ASSERT_EQ(1u, params.encodings.size());
params.encodings[0].max_bitrate_bps = 90000;
video_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; });
params, [&result](RTCError error) { result = error; });
run_loop_.Flush();
EXPECT_TRUE(result->ok());
params = video_rtp_sender_->GetParameters();
EXPECT_EQ(params.encodings[0].max_bitrate_bps, 90000);
video_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; });
params, [&result](RTCError error) { result = error; });
run_loop_.Flush();
EXPECT_TRUE(result->ok());
@ -1350,13 +1347,13 @@ TEST_F(RtpSenderReceiverTest,
RtpParameters params = video_rtp_sender_->GetParameters();
EXPECT_EQ(1u, params.encodings.size());
absl::optional<webrtc::RTCError> result;
absl::optional<RTCError> result;
video_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; });
params, [&result](RTCError error) { result = error; });
run_loop_.Flush();
EXPECT_TRUE(result->ok());
video_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; });
params, [&result](RTCError error) { result = error; });
run_loop_.Flush();
EXPECT_EQ(RTCErrorType::INVALID_STATE, result->type());
@ -1453,7 +1450,7 @@ TEST_F(RtpSenderReceiverTest, VideoSenderDetectInvalidNumTemporalLayers) {
CreateVideoRtpSender();
RtpParameters params = video_rtp_sender_->GetParameters();
params.encodings[0].num_temporal_layers = webrtc::kMaxTemporalStreams + 1;
params.encodings[0].num_temporal_layers = kMaxTemporalStreams + 1;
RTCError result = video_rtp_sender_->SetParameters(params);
EXPECT_EQ(RTCErrorType::INVALID_RANGE, result.type());
@ -1536,7 +1533,7 @@ TEST_F(RtpSenderReceiverTest, SetVideoMinMaxSendBitrate) {
CreateVideoRtpSender();
EXPECT_EQ(-1, video_media_send_channel()->max_bps());
webrtc::RtpParameters params = video_rtp_sender_->GetParameters();
RtpParameters params = video_rtp_sender_->GetParameters();
EXPECT_EQ(1U, params.encodings.size());
EXPECT_FALSE(params.encodings[0].min_bitrate_bps);
EXPECT_FALSE(params.encodings[0].max_bitrate_bps);
@ -1589,10 +1586,9 @@ TEST_F(RtpSenderReceiverTest, SetVideoMinMaxSendBitrateSimulcast) {
TEST_F(RtpSenderReceiverTest, SetVideoBitratePriority) {
CreateVideoRtpSender();
webrtc::RtpParameters params = video_rtp_sender_->GetParameters();
RtpParameters params = video_rtp_sender_->GetParameters();
EXPECT_EQ(1U, params.encodings.size());
EXPECT_EQ(webrtc::kDefaultBitratePriority,
params.encodings[0].bitrate_priority);
EXPECT_EQ(kDefaultBitratePriority, params.encodings[0].bitrate_priority);
double new_bitrate_priority = 2.0;
params.encodings[0].bitrate_priority = new_bitrate_priority;
EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok());

6
pc/rtp_transceiver.cc
View File

@ -542,7 +542,7 @@ bool RtpTransceiver::stopping() const {
RtpTransceiverDirection RtpTransceiver::direction() const {
if (unified_plan_ && stopping())
return webrtc::RtpTransceiverDirection::kStopped;
return RtpTransceiverDirection::kStopped;
return direction_;
}
@ -570,7 +570,7 @@ RTCError RtpTransceiver::SetDirectionWithError(
absl::optional<RtpTransceiverDirection> RtpTransceiver::current_direction()
const {
if (unified_plan_ && stopped())
return webrtc::RtpTransceiverDirection::kStopped;
return RtpTransceiverDirection::kStopped;
return current_direction_;
}
@ -604,7 +604,7 @@ void RtpTransceiver::StopSendingAndReceiving() {
});
stopping_ = true;
direction_ = webrtc::RtpTransceiverDirection::kInactive;
direction_ = RtpTransceiverDirection::kInactive;
}
RTCError RtpTransceiver::StopStandard() {

10
pc/rtp_transceiver.h
View File

@ -358,20 +358,18 @@ PROXY_CONSTMETHOD0(rtc::scoped_refptr<RtpReceiverInterface>, receiver)
PROXY_CONSTMETHOD0(bool, stopped)
PROXY_CONSTMETHOD0(bool, stopping)
PROXY_CONSTMETHOD0(RtpTransceiverDirection, direction)
PROXY_METHOD1(webrtc::RTCError, SetDirectionWithError, RtpTransceiverDirection)
PROXY_METHOD1(RTCError, SetDirectionWithError, RtpTransceiverDirection)
PROXY_CONSTMETHOD0(absl::optional<RtpTransceiverDirection>, current_direction)
PROXY_CONSTMETHOD0(absl::optional<RtpTransceiverDirection>, fired_direction)
PROXY_METHOD0(webrtc::RTCError, StopStandard)
PROXY_METHOD0(RTCError, StopStandard)
PROXY_METHOD0(void, StopInternal)
PROXY_METHOD1(webrtc::RTCError,
SetCodecPreferences,
rtc::ArrayView<RtpCodecCapability>)
PROXY_METHOD1(RTCError, SetCodecPreferences, rtc::ArrayView<RtpCodecCapability>)
PROXY_CONSTMETHOD0(std::vector<RtpCodecCapability>, codec_preferences)
PROXY_CONSTMETHOD0(std::vector<RtpHeaderExtensionCapability>,
GetHeaderExtensionsToNegotiate)
PROXY_CONSTMETHOD0(std::vector<RtpHeaderExtensionCapability>,
GetNegotiatedHeaderExtensions)
PROXY_METHOD1(webrtc::RTCError,
PROXY_METHOD1(RTCError,
SetHeaderExtensionsToNegotiate,
rtc::ArrayView<const RtpHeaderExtensionCapability>)
END_PROXY_MAP(RtpTransceiver)

11
pc/rtp_transceiver_unittest.cc
View File

@ -420,8 +420,8 @@ TEST_F(RtpTransceiverTestForHeaderExtensions, ReturnsNegotiatedHdrExts) {
EXPECT_CALL(*mock_channel, mid()).WillRepeatedly(ReturnRef(content_name));
EXPECT_CALL(*mock_channel, SetRtpTransport(_)).WillRepeatedly(Return(true));
cricket::RtpHeaderExtensions extensions = {webrtc::RtpExtension("uri1", 1),
webrtc::RtpExtension("uri2", 2)};
cricket::RtpHeaderExtensions extensions = {RtpExtension("uri1", 1),
RtpExtension("uri2", 2)};
cricket::AudioContentDescription description;
description.set_rtp_header_extensions(extensions);
transceiver_->OnNegotiationUpdate(SdpType::kAnswer, &description);
@ -449,8 +449,8 @@ TEST_F(RtpTransceiverTestForHeaderExtensions,
EXPECT_CALL(*sender_.get(), SetTransceiverAsStopped());
EXPECT_CALL(*sender_.get(), Stop());
cricket::RtpHeaderExtensions extensions = {webrtc::RtpExtension("uri1", 1),
webrtc::RtpExtension("uri2", 2)};
cricket::RtpHeaderExtensions extensions = {RtpExtension("uri1", 1),
RtpExtension("uri2", 2)};
cricket::AudioContentDescription description;
description.set_rtp_header_extensions(extensions);
transceiver_->OnNegotiationUpdate(SdpType::kAnswer, &description);
@ -464,8 +464,7 @@ TEST_F(RtpTransceiverTestForHeaderExtensions,
RtpTransceiverDirection::kStopped),
Field(&RtpHeaderExtensionCapability::direction,
RtpTransceiverDirection::kStopped)));
extensions = {webrtc::RtpExtension("uri3", 4),
webrtc::RtpExtension("uri5", 6)};
extensions = {RtpExtension("uri3", 4), RtpExtension("uri5", 6)};
description.set_rtp_header_extensions(extensions);
transceiver_->OnNegotiationUpdate(SdpType::kAnswer, &description);

8
pc/rtp_transport.cc
View File

@ -186,10 +186,10 @@ flat_set<uint32_t> RtpTransport::GetSsrcsForSink(RtpPacketSinkInterface* sink) {
void RtpTransport::DemuxPacket(rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us) {
webrtc::RtpPacketReceived parsed_packet(
&header_extension_map_, packet_time_us == -1
? Timestamp::MinusInfinity()
: Timestamp::Micros(packet_time_us));
RtpPacketReceived parsed_packet(&header_extension_map_,
packet_time_us == -1
? Timestamp::MinusInfinity()
: Timestamp::Micros(packet_time_us));
if (!parsed_packet.Parse(std::move(packet))) {
RTC_LOG(LS_ERROR)
<< "Failed to parse the incoming RTP packet before demuxing. Drop it.";

4
pc/rtp_transport_internal.h
View File

@ -72,7 +72,7 @@ class RtpTransportInternal : public sigslot::has_slots<> {
// Called whenever a RTP packet that can not be demuxed by the transport is
// received.
void SetUnDemuxableRtpPacketReceivedHandler(
absl::AnyInvocable<void(webrtc::RtpPacketReceived&)> callback) {
absl::AnyInvocable<void(RtpPacketReceived&)> callback) {
callback_undemuxable_rtp_packet_received_ = std::move(callback);
}
@ -160,7 +160,7 @@ class RtpTransportInternal : public sigslot::has_slots<> {
CallbackList<bool> callback_list_ready_to_send_;
CallbackList<rtc::CopyOnWriteBuffer*, int64_t>
callback_list_rtcp_packet_received_;
absl::AnyInvocable<void(webrtc::RtpPacketReceived&)>
absl::AnyInvocable<void(RtpPacketReceived&)>
callback_undemuxable_rtp_packet_received_ =
[](RtpPacketReceived& packet) {};
CallbackList<absl::optional<rtc::NetworkRoute>>

2
pc/sctp_transport.h
View File

@ -61,7 +61,7 @@ class SctpTransport : public SctpTransportInterface,
void Start(int local_port, int remote_port, int max_message_size);
// TODO(https://bugs.webrtc.org/10629): Move functions that need
// internal() to be functions on the webrtc::SctpTransport interface,
// internal() to be functions on the SctpTransport interface,
// and make the internal() function private.
cricket::SctpTransportInternal* internal() {
RTC_DCHECK_RUN_ON(owner_thread_);

9
pc/sdp_offer_answer.cc
View File

@ -86,8 +86,7 @@ namespace webrtc {
namespace {
typedef webrtc::PeerConnectionInterface::RTCOfferAnswerOptions
RTCOfferAnswerOptions;
typedef PeerConnectionInterface::RTCOfferAnswerOptions RTCOfferAnswerOptions;
// Error messages
const char kInvalidSdp[] = "Invalid session description.";
@ -834,8 +833,8 @@ std::string GenerateRtcpCname() {
}
// Check if we can send `new_stream` on a PeerConnection.
bool CanAddLocalMediaStream(webrtc::StreamCollectionInterface* current_streams,
webrtc::MediaStreamInterface* new_stream) {
bool CanAddLocalMediaStream(StreamCollectionInterface* current_streams,
MediaStreamInterface* new_stream) {
if (!new_stream || !current_streams) {
return false;
}
@ -847,7 +846,7 @@ bool CanAddLocalMediaStream(webrtc::StreamCollectionInterface* current_streams,
return true;
}
rtc::scoped_refptr<webrtc::DtlsTransport> LookupDtlsTransportByMid(
rtc::scoped_refptr<DtlsTransport> LookupDtlsTransportByMid(
rtc::Thread* network_thread,
JsepTransportController* controller,
const std::string& mid) {

4
pc/sdp_offer_answer.h
View File

@ -674,8 +674,8 @@ class SdpOfferAnswerHandler : public SdpStateProvider {
// or else the CreateBuiltinVideoBitrateAllocatorFactory() will be called.
// Note that one can still choose to override this in a MediaEngine
// if one wants too.
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory_ RTC_GUARDED_BY(signaling_thread());
std::unique_ptr<VideoBitrateAllocatorFactory> video_bitrate_allocator_factory_
RTC_GUARDED_BY(signaling_thread());
// Whether we are the initial offerer on the association. This
// determines the SSL role.

20
pc/sdp_offer_answer_unittest.cc
View File

@ -88,7 +88,7 @@ class SdpOfferAnswerTest : public ::testing::Test {
Dav1dDecoderTemplateAdapter>>(),
nullptr /* audio_mixer */,
nullptr /* audio_processing */)) {
webrtc::metrics::Reset();
metrics::Reset();
}
std::unique_ptr<PeerConnectionWrapper> CreatePeerConnection() {
@ -168,8 +168,8 @@ TEST_F(SdpOfferAnswerTest, BundleRejectsCodecCollisionsAudioVideo) {
// There is no error yet but the metrics counter will increase.
EXPECT_TRUE(error.ok());
EXPECT_METRIC_EQ(
1, webrtc::metrics::NumEvents(
"WebRTC.PeerConnection.ValidBundledPayloadTypes", false));
1, metrics::NumEvents("WebRTC.PeerConnection.ValidBundledPayloadTypes",
false));
// Tolerate codec collisions in rejected m-lines.
pc = CreatePeerConnection();
@ -178,9 +178,9 @@ TEST_F(SdpOfferAnswerTest, BundleRejectsCodecCollisionsAudioVideo) {
absl::StrReplaceAll(sdp, {{"m=video 9 ", "m=video 0 "}}));
pc->SetRemoteDescription(std::move(rejected_offer), &error);
EXPECT_TRUE(error.ok());
EXPECT_METRIC_EQ(1,
webrtc::metrics::NumEvents(
"WebRTC.PeerConnection.ValidBundledPayloadTypes", true));
EXPECT_METRIC_EQ(
1, metrics::NumEvents("WebRTC.PeerConnection.ValidBundledPayloadTypes",
true));
}
TEST_F(SdpOfferAnswerTest, BundleRejectsCodecCollisionsVideoFmtp) {
@ -221,8 +221,8 @@ TEST_F(SdpOfferAnswerTest, BundleRejectsCodecCollisionsVideoFmtp) {
pc->SetRemoteDescription(std::move(desc), &error);
EXPECT_TRUE(error.ok());
EXPECT_METRIC_EQ(
1, webrtc::metrics::NumEvents(
"WebRTC.PeerConnection.ValidBundledPayloadTypes", false));
1, metrics::NumEvents("WebRTC.PeerConnection.ValidBundledPayloadTypes",
false));
}
TEST_F(SdpOfferAnswerTest, BundleCodecCollisionInDifferentBundlesAllowed) {
@ -264,8 +264,8 @@ TEST_F(SdpOfferAnswerTest, BundleCodecCollisionInDifferentBundlesAllowed) {
pc->SetRemoteDescription(std::move(desc), &error);
EXPECT_TRUE(error.ok());
EXPECT_METRIC_EQ(
0, webrtc::metrics::NumEvents(
"WebRTC.PeerConnection.ValidBundledPayloadTypes", false));
0, metrics::NumEvents("WebRTC.PeerConnection.ValidBundledPayloadTypes",
false));
}
TEST_F(SdpOfferAnswerTest, BundleMeasuresHeaderExtensionIdCollision) {

12
pc/slow_peer_connection_integration_test.cc
View File

@ -67,7 +67,7 @@ class FakeClockForTest : public rtc::ScopedFakeClock {
// Some things use a time of "0" as a special value, so we need to start out
// the fake clock at a nonzero time.
// TODO(deadbeef): Fix this.
AdvanceTime(webrtc::TimeDelta::Seconds(1000));
AdvanceTime(TimeDelta::Seconds(1000));
}
// Explicit handle.
@ -170,20 +170,20 @@ TEST_P(PeerConnectionIntegrationTest,
CreateTurnServer(turn_server_internal_address, turn_server_external_address,
cricket::PROTO_TLS, "88.88.88.0");
webrtc::PeerConnectionInterface::IceServer ice_server;
PeerConnectionInterface::IceServer ice_server;
ice_server.urls.push_back("turns:88.88.88.0:3478?transport=tcp");
ice_server.username = "test";
ice_server.password = "test";
PeerConnectionInterface::RTCConfiguration client_1_config;
client_1_config.servers.push_back(ice_server);
client_1_config.type = webrtc::PeerConnectionInterface::kRelay;
client_1_config.type = PeerConnectionInterface::kRelay;
PeerConnectionInterface::RTCConfiguration client_2_config;
client_2_config.servers.push_back(ice_server);
// Setting the type to kRelay forces the connection to go through a TURN
// server.
client_2_config.type = webrtc::PeerConnectionInterface::kRelay;
client_2_config.type = PeerConnectionInterface::kRelay;
// Get a copy to the pointer so we can verify calls later.
rtc::TestCertificateVerifier* client_1_cert_verifier =
@ -194,10 +194,10 @@ TEST_P(PeerConnectionIntegrationTest,
client_2_cert_verifier->verify_certificate_ = false;
// Create the dependencies with the test certificate verifier.
webrtc::PeerConnectionDependencies client_1_deps(nullptr);
PeerConnectionDependencies client_1_deps(nullptr);
client_1_deps.tls_cert_verifier =
std::unique_ptr<rtc::TestCertificateVerifier>(client_1_cert_verifier);
webrtc::PeerConnectionDependencies client_2_deps(nullptr);
PeerConnectionDependencies client_2_deps(nullptr);
client_2_deps.tls_cert_verifier =
std::unique_ptr<rtc::TestCertificateVerifier>(client_2_cert_verifier);

2
pc/srtp_transport_unittest.cc
View File

@ -342,7 +342,7 @@ class SrtpTransportTest : public ::testing::Test, public sigslot::has_slots<> {
TransportObserver rtp_sink2_;
int sequence_number_ = 0;
webrtc::test::ScopedKeyValueConfig field_trials_;
test::ScopedKeyValueConfig field_trials_;
};
class SrtpTransportTestWithExternalAuth

2
pc/test/android_test_initializer.cc
View File

@ -39,7 +39,7 @@ void EnsureInitializedOnce() {
RTC_CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()";
webrtc::JVM::Initialize(jvm);
JVM::Initialize(jvm);
}
} // anonymous namespace

2
pc/test/fake_peer_connection_base.h
View File

@ -363,7 +363,7 @@ class FakePeerConnectionBase : public PeerConnectionInternal {
const FieldTrialsView& trials() const override { return field_trials_; }
protected:
webrtc::test::ScopedKeyValueConfig field_trials_;
test::ScopedKeyValueConfig field_trials_;
};
} // namespace webrtc

8
pc/test/fake_peer_connection_for_stats.h
View File

@ -150,7 +150,7 @@ class VoiceChannelForTesting : public cricket::VoiceChannel {
receive_channel,
const std::string& content_name,
bool srtp_required,
webrtc::CryptoOptions crypto_options,
CryptoOptions crypto_options,
rtc::UniqueRandomIdGenerator* ssrc_generator,
std::string transport_name)
: VoiceChannel(worker_thread,
@ -183,7 +183,7 @@ class VideoChannelForTesting : public cricket::VideoChannel {
receive_channel,
const std::string& content_name,
bool srtp_required,
webrtc::CryptoOptions crypto_options,
CryptoOptions crypto_options,
rtc::UniqueRandomIdGenerator* ssrc_generator,
std::string transport_name)
: VideoChannel(worker_thread,
@ -298,7 +298,7 @@ class FakePeerConnectionForStats : public FakePeerConnectionBase {
worker_thread_, network_thread_, signaling_thread_,
std::move(voice_media_send_channel),
std::move(voice_media_receive_channel), mid, kDefaultSrtpRequired,
webrtc::CryptoOptions(), context_->ssrc_generator(), transport_name);
CryptoOptions(), context_->ssrc_generator(), transport_name);
auto transceiver =
GetOrCreateFirstTransceiverOfType(cricket::MEDIA_TYPE_AUDIO)
->internal();
@ -332,7 +332,7 @@ class FakePeerConnectionForStats : public FakePeerConnectionBase {
worker_thread_, network_thread_, signaling_thread_,
std::move(video_media_send_channel),
std::move(video_media_receive_channel), mid, kDefaultSrtpRequired,
webrtc::CryptoOptions(), context_->ssrc_generator(), transport_name);
CryptoOptions(), context_->ssrc_generator(), transport_name);
auto transceiver =
GetOrCreateFirstTransceiverOfType(cricket::MEDIA_TYPE_VIDEO)
->internal();

4
pc/test/fake_periodic_video_source.h
View File

@ -65,12 +65,12 @@ class FakePeriodicVideoSource final
return wants_;
}
void RemoveSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override {
void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override {
RTC_DCHECK(thread_checker_.IsCurrent());
broadcaster_.RemoveSink(sink);
}
void AddOrUpdateSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
const rtc::VideoSinkWants& wants) override {
RTC_DCHECK(thread_checker_.IsCurrent());
{

2
pc/test/integration_test_helpers.cc
View File

@ -46,7 +46,7 @@ void RemoveSsrcsAndKeepMsids(cricket::SessionDescription* desc) {
int FindFirstMediaStatsIndexByKind(
const std::string& kind,
const std::vector<const webrtc::RTCInboundRtpStreamStats*>& inbound_rtps) {
const std::vector<const RTCInboundRtpStreamStats*>& inbound_rtps) {
for (size_t i = 0; i < inbound_rtps.size(); i++) {
if (*inbound_rtps[i]->kind == kind) {
return i;

259
pc/test/integration_test_helpers.h
View File

@ -177,14 +177,14 @@ void ReplaceFirstSsrc(StreamParams& stream, uint32_t ssrc);
int FindFirstMediaStatsIndexByKind(
const std::string& kind,
const std::vector<const webrtc::RTCInboundRtpStreamStats*>& inbound_rtps);
const std::vector<const RTCInboundRtpStreamStats*>& inbound_rtps);
class TaskQueueMetronome : public webrtc::Metronome {
class TaskQueueMetronome : public Metronome {
public:
explicit TaskQueueMetronome(TimeDelta tick_period);
~TaskQueueMetronome() override;
// webrtc::Metronome implementation.
// Metronome implementation.
void RequestCallOnNextTick(absl::AnyInvocable<void() &&> callback) override;
TimeDelta TickPeriod() const override;
@ -207,7 +207,7 @@ class SignalingMessageReceiver {
virtual ~SignalingMessageReceiver() {}
};
class MockRtpReceiverObserver : public webrtc::RtpReceiverObserverInterface {
class MockRtpReceiverObserver : public RtpReceiverObserverInterface {
public:
explicit MockRtpReceiverObserver(cricket::MediaType media_type)
: expected_media_type_(media_type) {}
@ -234,14 +234,14 @@ class MockRtpReceiverObserver : public webrtc::RtpReceiverObserverInterface {
// advertise support of any codecs.
// TODO(steveanton): See how this could become a subclass of
// PeerConnectionWrapper defined in peerconnectionwrapper.h.
class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
class PeerConnectionIntegrationWrapper : public PeerConnectionObserver,
public SignalingMessageReceiver {
public:
webrtc::PeerConnectionFactoryInterface* pc_factory() const {
PeerConnectionFactoryInterface* pc_factory() const {
return peer_connection_factory_.get();
}
webrtc::PeerConnectionInterface* pc() const { return peer_connection_.get(); }
PeerConnectionInterface* pc() const { return peer_connection_.get(); }
// If a signaling message receiver is set (via ConnectFakeSignaling), this
// will set the whole offer/answer exchange in motion. Just need to wait for
@ -339,11 +339,11 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
return AddTrack(CreateLocalVideoTrack());
}
rtc::scoped_refptr<webrtc::AudioTrackInterface> CreateLocalAudioTrack() {
rtc::scoped_refptr<AudioTrackInterface> CreateLocalAudioTrack() {
cricket::AudioOptions options;
// Disable highpass filter so that we can get all the test audio frames.
options.highpass_filter = false;
rtc::scoped_refptr<webrtc::AudioSourceInterface> source =
rtc::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.
@ -351,21 +351,20 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
source.get());
}
rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrack() {
webrtc::FakePeriodicVideoSource::Config config;
rtc::scoped_refptr<VideoTrackInterface> CreateLocalVideoTrack() {
FakePeriodicVideoSource::Config config;
config.timestamp_offset_ms = rtc::TimeMillis();
return CreateLocalVideoTrackInternal(config);
}
rtc::scoped_refptr<webrtc::VideoTrackInterface>
CreateLocalVideoTrackWithConfig(
webrtc::FakePeriodicVideoSource::Config config) {
rtc::scoped_refptr<VideoTrackInterface> CreateLocalVideoTrackWithConfig(
FakePeriodicVideoSource::Config config) {
return CreateLocalVideoTrackInternal(config);
}
rtc::scoped_refptr<webrtc::VideoTrackInterface>
CreateLocalVideoTrackWithRotation(webrtc::VideoRotation rotation) {
webrtc::FakePeriodicVideoSource::Config config;
rtc::scoped_refptr<VideoTrackInterface> CreateLocalVideoTrackWithRotation(
VideoRotation rotation) {
FakePeriodicVideoSource::Config config;
config.rotation = rotation;
config.timestamp_offset_ms = rtc::TimeMillis();
return CreateLocalVideoTrackInternal(config);
@ -409,22 +408,22 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
}
bool SignalingStateStable() {
return pc()->signaling_state() == webrtc::PeerConnectionInterface::kStable;
return pc()->signaling_state() == PeerConnectionInterface::kStable;
}
bool IceGatheringStateComplete() {
return pc()->ice_gathering_state() ==
webrtc::PeerConnectionInterface::kIceGatheringComplete;
PeerConnectionInterface::kIceGatheringComplete;
}
void CreateDataChannel() { CreateDataChannel(nullptr); }
void CreateDataChannel(const webrtc::DataChannelInit* init) {
void CreateDataChannel(const DataChannelInit* init) {
CreateDataChannel(kDataChannelLabel, init);
}
void CreateDataChannel(const std::string& label,
const webrtc::DataChannelInit* init) {
const DataChannelInit* init) {
auto data_channel_or_error = pc()->CreateDataChannelOrError(label, init);
ASSERT_TRUE(data_channel_or_error.ok());
data_channels_.push_back(data_channel_or_error.MoveValue());
@ -482,7 +481,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
// Returns a MockStatsObserver in a state after stats gathering finished,
// which can be used to access the gathered stats.
rtc::scoped_refptr<MockStatsObserver> OldGetStatsForTrack(
webrtc::MediaStreamTrackInterface* track) {
MediaStreamTrackInterface* track) {
auto observer = rtc::make_ref_counted<MockStatsObserver>();
EXPECT_TRUE(peer_connection_->GetStats(
observer.get(), nullptr,
@ -498,9 +497,8 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
// Synchronously gets stats and returns them. If it times out, fails the test
// and returns null.
rtc::scoped_refptr<const webrtc::RTCStatsReport> NewGetStats() {
auto callback =
rtc::make_ref_counted<webrtc::MockRTCStatsCollectorCallback>();
rtc::scoped_refptr<const RTCStatsReport> NewGetStats() {
auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>();
peer_connection_->GetStats(callback.get());
EXPECT_TRUE_WAIT(callback->called(), kDefaultTimeout);
return callback->report();
@ -527,10 +525,10 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
return static_cast<double>(rendered_width()) / rendered_height();
}
webrtc::VideoRotation rendered_rotation() {
VideoRotation rendered_rotation() {
EXPECT_FALSE(fake_video_renderers_.empty());
return fake_video_renderers_.empty()
? webrtc::kVideoRotation_0
? kVideoRotation_0
: fake_video_renderers_.begin()->second->rotation();
}
@ -573,20 +571,20 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
return pc()->local_streams().get();
}
webrtc::PeerConnectionInterface::SignalingState signaling_state() {
PeerConnectionInterface::SignalingState signaling_state() {
return pc()->signaling_state();
}
webrtc::PeerConnectionInterface::IceConnectionState ice_connection_state() {
PeerConnectionInterface::IceConnectionState ice_connection_state() {
return pc()->ice_connection_state();
}
webrtc::PeerConnectionInterface::IceConnectionState
PeerConnectionInterface::IceConnectionState
standardized_ice_connection_state() {
return pc()->standardized_ice_connection_state();
}
webrtc::PeerConnectionInterface::IceGatheringState ice_gathering_state() {
PeerConnectionInterface::IceGatheringState ice_gathering_state() {
return pc()->ice_gathering_state();
}
@ -615,7 +613,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
}
cricket::PortAllocator* port_allocator() const { return port_allocator_; }
webrtc::FakeRtcEventLogFactory* event_log_factory() const {
FakeRtcEventLogFactory* event_log_factory() const {
return event_log_factory_;
}
@ -628,8 +626,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
// Sets the mDNS responder for the owned fake network manager and keeps a
// reference to the responder.
void SetMdnsResponder(
std::unique_ptr<webrtc::FakeMdnsResponder> mdns_responder) {
void SetMdnsResponder(std::unique_ptr<FakeMdnsResponder> mdns_responder) {
RTC_DCHECK(mdns_responder != nullptr);
mdns_responder_ = mdns_responder.get();
network_manager()->set_mdns_responder(std::move(mdns_responder));
@ -644,7 +641,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
}
bool Rollback() {
return SetRemoteDescription(
webrtc::CreateSessionDescription(SdpType::kRollback, ""));
CreateSessionDescription(SdpType::kRollback, ""));
}
// Functions for querying stats.
@ -652,7 +649,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
// Get the baseline numbers for audio_packets and audio_delay.
auto received_stats = NewGetStats();
auto rtp_stats =
received_stats->GetStatsOfType<webrtc::RTCInboundRtpStreamStats>()[0];
received_stats->GetStatsOfType<RTCInboundRtpStreamStats>()[0];
ASSERT_TRUE(rtp_stats->relative_packet_arrival_delay.is_defined());
ASSERT_TRUE(rtp_stats->packets_received.is_defined());
rtp_stats_id_ = rtp_stats->id();
@ -664,8 +661,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
void UpdateDelayStats(std::string tag, int desc_size) {
auto report = NewGetStats();
auto rtp_stats =
report->GetAs<webrtc::RTCInboundRtpStreamStats>(rtp_stats_id_);
auto rtp_stats = report->GetAs<RTCInboundRtpStreamStats>(rtp_stats_id_);
ASSERT_TRUE(rtp_stats);
auto delta_packets = *rtp_stats->packets_received - audio_packets_stat_;
auto delta_rpad =
@ -744,11 +740,11 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
bool Init(const PeerConnectionFactory::Options* options,
const PeerConnectionInterface::RTCConfiguration* config,
webrtc::PeerConnectionDependencies dependencies,
PeerConnectionDependencies dependencies,
rtc::SocketServer* socket_server,
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
std::unique_ptr<webrtc::FakeRtcEventLogFactory> event_log_factory,
std::unique_ptr<FakeRtcEventLogFactory> event_log_factory,
bool reset_encoder_factory,
bool reset_decoder_factory,
bool create_media_engine) {
@ -771,12 +767,12 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
}
rtc::Thread* const signaling_thread = rtc::Thread::Current();
webrtc::PeerConnectionFactoryDependencies pc_factory_dependencies;
PeerConnectionFactoryDependencies pc_factory_dependencies;
pc_factory_dependencies.network_thread = network_thread;
pc_factory_dependencies.worker_thread = worker_thread;
pc_factory_dependencies.signaling_thread = signaling_thread;
pc_factory_dependencies.task_queue_factory =
webrtc::CreateDefaultTaskQueueFactory();
CreateDefaultTaskQueueFactory();
pc_factory_dependencies.trials = std::make_unique<FieldTrialBasedConfig>();
pc_factory_dependencies.metronome =
std::make_unique<TaskQueueMetronome>(TimeDelta::Millis(8));
@ -805,11 +801,11 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
pc_factory_dependencies.event_log_factory = std::move(event_log_factory);
} else {
pc_factory_dependencies.event_log_factory =
std::make_unique<webrtc::RtcEventLogFactory>(
std::make_unique<RtcEventLogFactory>(
pc_factory_dependencies.task_queue_factory.get());
}
peer_connection_factory_ = webrtc::CreateModularPeerConnectionFactory(
std::move(pc_factory_dependencies));
peer_connection_factory_ =
CreateModularPeerConnectionFactory(std::move(pc_factory_dependencies));
if (!peer_connection_factory_) {
return false;
@ -826,9 +822,9 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
return peer_connection_.get() != nullptr;
}
rtc::scoped_refptr<webrtc::PeerConnectionInterface> CreatePeerConnection(
rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
const PeerConnectionInterface::RTCConfiguration* config,
webrtc::PeerConnectionDependencies dependencies) {
PeerConnectionDependencies dependencies) {
PeerConnectionInterface::RTCConfiguration modified_config;
modified_config.sdp_semantics = sdp_semantics_;
// If `config` is null, this will result in a default configuration being
@ -861,21 +857,20 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
signal_ice_candidates_ = signal;
}
rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrackInternal(
webrtc::FakePeriodicVideoSource::Config config) {
rtc::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<webrtc::FakePeriodicVideoTrackSource>(
rtc::make_ref_counted<FakePeriodicVideoTrackSource>(
config, false /* remote */));
rtc::scoped_refptr<webrtc::VideoTrackInterface> track =
rtc::scoped_refptr<VideoTrackInterface> track =
peer_connection_factory_->CreateVideoTrack(video_track_sources_.back(),
rtc::CreateRandomUuid());
if (!local_video_renderer_) {
local_video_renderer_.reset(
new webrtc::FakeVideoTrackRenderer(track.get()));
local_video_renderer_.reset(new FakeVideoTrackRenderer(track.get()));
}
return track;
}
@ -883,7 +878,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
void HandleIncomingOffer(const std::string& msg) {
RTC_LOG(LS_INFO) << debug_name_ << ": HandleIncomingOffer";
std::unique_ptr<SessionDescriptionInterface> desc =
webrtc::CreateSessionDescription(SdpType::kOffer, msg);
CreateSessionDescription(SdpType::kOffer, msg);
if (received_sdp_munger_) {
received_sdp_munger_(desc->description());
}
@ -903,7 +898,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
void HandleIncomingAnswer(const std::string& msg) {
RTC_LOG(LS_INFO) << debug_name_ << ": HandleIncomingAnswer";
std::unique_ptr<SessionDescriptionInterface> desc =
webrtc::CreateSessionDescription(SdpType::kAnswer, msg);
CreateSessionDescription(SdpType::kAnswer, msg);
if (received_sdp_munger_) {
received_sdp_munger_(desc->description());
}
@ -1054,7 +1049,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
const std::string& msg) override {
RTC_LOG(LS_INFO) << debug_name_ << ": ReceiveIceMessage";
absl::optional<RTCError> result;
pc()->AddIceCandidate(absl::WrapUnique(webrtc::CreateIceCandidate(
pc()->AddIceCandidate(absl::WrapUnique(CreateIceCandidate(
sdp_mid, sdp_mline_index, msg, nullptr)),
[&result](RTCError r) { result = r; });
EXPECT_TRUE_WAIT(result.has_value(), kDefaultTimeout);
@ -1063,7 +1058,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
// PeerConnectionObserver callbacks.
void OnSignalingChange(
webrtc::PeerConnectionInterface::SignalingState new_state) override {
PeerConnectionInterface::SignalingState new_state) override {
EXPECT_EQ(pc()->signaling_state(), new_state);
peer_connection_signaling_state_history_.push_back(new_state);
}
@ -1092,21 +1087,21 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
}
void OnRenegotiationNeeded() override {}
void OnIceConnectionChange(
webrtc::PeerConnectionInterface::IceConnectionState new_state) override {
PeerConnectionInterface::IceConnectionState new_state) override {
EXPECT_EQ(pc()->ice_connection_state(), new_state);
ice_connection_state_history_.push_back(new_state);
}
void OnStandardizedIceConnectionChange(
webrtc::PeerConnectionInterface::IceConnectionState new_state) override {
PeerConnectionInterface::IceConnectionState new_state) override {
standardized_ice_connection_state_history_.push_back(new_state);
}
void OnConnectionChange(
webrtc::PeerConnectionInterface::PeerConnectionState new_state) override {
PeerConnectionInterface::PeerConnectionState new_state) override {
peer_connection_state_history_.push_back(new_state);
}
void OnIceGatheringChange(
webrtc::PeerConnectionInterface::IceGatheringState new_state) override {
PeerConnectionInterface::IceGatheringState new_state) override {
EXPECT_EQ(pc()->ice_gathering_state(), new_state);
ice_gathering_state_history_.push_back(new_state);
}
@ -1116,7 +1111,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
ice_candidate_pair_change_history_.push_back(event);
}
void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override {
void OnIceCandidate(const IceCandidateInterface* candidate) override {
RTC_LOG(LS_INFO) << debug_name_ << ": OnIceCandidate";
if (remote_async_dns_resolver_) {
@ -1172,20 +1167,19 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
std::unique_ptr<rtc::FakeNetworkManager> fake_network_manager_;
std::unique_ptr<rtc::BasicPacketSocketFactory> socket_factory_;
// Reference to the mDNS responder owned by `fake_network_manager_` after set.
webrtc::FakeMdnsResponder* mdns_responder_ = nullptr;
FakeMdnsResponder* mdns_responder_ = nullptr;
rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
peer_connection_factory_;
rtc::scoped_refptr<PeerConnectionInterface> peer_connection_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> peer_connection_factory_;
cricket::PortAllocator* port_allocator_;
// Needed to keep track of number of frames sent.
rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
// Needed to keep track of number of frames received.
std::map<std::string, std::unique_ptr<webrtc::FakeVideoTrackRenderer>>
std::map<std::string, std::unique_ptr<FakeVideoTrackRenderer>>
fake_video_renderers_;
// Needed to ensure frames aren't received for removed tracks.
std::vector<std::unique_ptr<webrtc::FakeVideoTrackRenderer>>
std::vector<std::unique_ptr<FakeVideoTrackRenderer>>
removed_fake_video_renderers_;
// For remote peer communication.
@ -1197,10 +1191,9 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
// Store references to the video sources we've created, so that we can stop
// them, if required.
std::vector<rtc::scoped_refptr<webrtc::VideoTrackSource>>
video_track_sources_;
std::vector<rtc::scoped_refptr<VideoTrackSource>> video_track_sources_;
// `local_video_renderer_` attached to the first created local video track.
std::unique_ptr<webrtc::FakeVideoTrackRenderer> local_video_renderer_;
std::unique_ptr<FakeVideoTrackRenderer> local_video_renderer_;
SdpSemantics sdp_semantics_;
PeerConnectionInterface::RTCOfferAnswerOptions offer_answer_options_;
@ -1230,7 +1223,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
ice_candidate_pair_change_history_;
std::vector<PeerConnectionInterface::SignalingState>
peer_connection_signaling_state_history_;
webrtc::FakeRtcEventLogFactory* event_log_factory_;
FakeRtcEventLogFactory* event_log_factory_;
// Number of ICE candidates expected. The default is no limit.
int candidates_expected_ = std::numeric_limits<int>::max();
@ -1247,7 +1240,7 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
friend class PeerConnectionIntegrationBaseTest;
};
class MockRtcEventLogOutput : public webrtc::RtcEventLogOutput {
class MockRtcEventLogOutput : public RtcEventLogOutput {
public:
virtual ~MockRtcEventLogOutput() = default;
MOCK_METHOD(bool, IsActive, (), (const, override));
@ -1359,7 +1352,7 @@ class MediaExpectations {
int callee_video_frames_expected_ = 0;
};
class MockIceTransport : public webrtc::IceTransportInterface {
class MockIceTransport : public IceTransportInterface {
public:
MockIceTransport(const std::string& name, int component)
: internal_(std::make_unique<cricket::FakeIceTransport>(
@ -1407,7 +1400,7 @@ class PeerConnectionIntegrationBaseTest : public ::testing::Test {
worker_thread_->SetName("PCWorkerThread", this);
RTC_CHECK(network_thread_->Start());
RTC_CHECK(worker_thread_->Start());
webrtc::metrics::Reset();
metrics::Reset();
}
~PeerConnectionIntegrationBaseTest() {
@ -1444,13 +1437,13 @@ class PeerConnectionIntegrationBaseTest : public ::testing::Test {
// are connected. This is an important distinction. Once we have separate
// ICE and DTLS state, this check needs to use the DTLS state.
return (callee()->ice_connection_state() ==
webrtc::PeerConnectionInterface::kIceConnectionConnected ||
PeerConnectionInterface::kIceConnectionConnected ||
callee()->ice_connection_state() ==
webrtc::PeerConnectionInterface::kIceConnectionCompleted) &&
PeerConnectionInterface::kIceConnectionCompleted) &&
(caller()->ice_connection_state() ==
webrtc::PeerConnectionInterface::kIceConnectionConnected ||
PeerConnectionInterface::kIceConnectionConnected ||
caller()->ice_connection_state() ==
webrtc::PeerConnectionInterface::kIceConnectionCompleted);
PeerConnectionInterface::kIceConnectionCompleted);
}
// When `event_log_factory` is null, the default implementation of the event
@ -1459,8 +1452,8 @@ class PeerConnectionIntegrationBaseTest : public ::testing::Test {
const std::string& debug_name,
const PeerConnectionFactory::Options* options,
const RTCConfiguration* config,
webrtc::PeerConnectionDependencies dependencies,
std::unique_ptr<webrtc::FakeRtcEventLogFactory> event_log_factory,
PeerConnectionDependencies dependencies,
std::unique_ptr<FakeRtcEventLogFactory> event_log_factory,
bool reset_encoder_factory,
bool reset_decoder_factory,
bool create_media_engine = true) {
@ -1490,10 +1483,10 @@ class PeerConnectionIntegrationBaseTest : public ::testing::Test {
const std::string& debug_name,
const PeerConnectionFactory::Options* options,
const RTCConfiguration* config,
webrtc::PeerConnectionDependencies dependencies) {
PeerConnectionDependencies dependencies) {
return CreatePeerConnectionWrapper(
debug_name, options, config, std::move(dependencies),
std::make_unique<webrtc::FakeRtcEventLogFactory>(),
std::make_unique<FakeRtcEventLogFactory>(),
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false);
}
@ -1514,17 +1507,17 @@ class PeerConnectionIntegrationBaseTest : public ::testing::Test {
// callee PeerConnections.
SdpSemantics original_semantics = sdp_semantics_;
sdp_semantics_ = caller_semantics;
caller_ = CreatePeerConnectionWrapper(
"Caller", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false);
caller_ = CreatePeerConnectionWrapper("Caller", nullptr, nullptr,
PeerConnectionDependencies(nullptr),
nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false);
sdp_semantics_ = callee_semantics;
callee_ = CreatePeerConnectionWrapper(
"Callee", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false);
callee_ = CreatePeerConnectionWrapper("Callee", nullptr, nullptr,
PeerConnectionDependencies(nullptr),
nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false);
sdp_semantics_ = original_semantics;
return caller_ && callee_;
}
@ -1532,24 +1525,24 @@ class PeerConnectionIntegrationBaseTest : public ::testing::Test {
bool CreatePeerConnectionWrappersWithConfig(
const PeerConnectionInterface::RTCConfiguration& caller_config,
const PeerConnectionInterface::RTCConfiguration& callee_config) {
caller_ = CreatePeerConnectionWrapper(
"Caller", nullptr, &caller_config,
webrtc::PeerConnectionDependencies(nullptr), nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false);
callee_ = CreatePeerConnectionWrapper(
"Callee", nullptr, &callee_config,
webrtc::PeerConnectionDependencies(nullptr), nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false);
caller_ = CreatePeerConnectionWrapper("Caller", nullptr, &caller_config,
PeerConnectionDependencies(nullptr),
nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false);
callee_ = CreatePeerConnectionWrapper("Callee", nullptr, &callee_config,
PeerConnectionDependencies(nullptr),
nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false);
return caller_ && callee_;
}
bool CreatePeerConnectionWrappersWithConfigAndDeps(
const PeerConnectionInterface::RTCConfiguration& caller_config,
webrtc::PeerConnectionDependencies caller_dependencies,
PeerConnectionDependencies caller_dependencies,
const PeerConnectionInterface::RTCConfiguration& callee_config,
webrtc::PeerConnectionDependencies callee_dependencies) {
PeerConnectionDependencies callee_dependencies) {
caller_ =
CreatePeerConnectionWrapper("Caller", nullptr, &caller_config,
std::move(caller_dependencies), nullptr,
@ -1566,16 +1559,16 @@ class PeerConnectionIntegrationBaseTest : public ::testing::Test {
bool CreatePeerConnectionWrappersWithOptions(
const PeerConnectionFactory::Options& caller_options,
const PeerConnectionFactory::Options& callee_options) {
caller_ = CreatePeerConnectionWrapper(
"Caller", &caller_options, nullptr,
webrtc::PeerConnectionDependencies(nullptr), nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false);
callee_ = CreatePeerConnectionWrapper(
"Callee", &callee_options, nullptr,
webrtc::PeerConnectionDependencies(nullptr), nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false);
caller_ = CreatePeerConnectionWrapper("Caller", &caller_options, nullptr,
PeerConnectionDependencies(nullptr),
nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false);
callee_ = CreatePeerConnectionWrapper("Callee", &callee_options, nullptr,
PeerConnectionDependencies(nullptr),
nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false);
return caller_ && callee_;
}
@ -1583,10 +1576,10 @@ class PeerConnectionIntegrationBaseTest : public ::testing::Test {
PeerConnectionInterface::RTCConfiguration default_config;
caller_ = CreatePeerConnectionWrapperWithFakeRtcEventLog(
"Caller", nullptr, &default_config,
webrtc::PeerConnectionDependencies(nullptr));
PeerConnectionDependencies(nullptr));
callee_ = CreatePeerConnectionWrapperWithFakeRtcEventLog(
"Callee", nullptr, &default_config,
webrtc::PeerConnectionDependencies(nullptr));
PeerConnectionDependencies(nullptr));
return caller_ && callee_;
}
@ -1596,7 +1589,7 @@ class PeerConnectionIntegrationBaseTest : public ::testing::Test {
new FakeRTCCertificateGenerator());
cert_generator->use_alternate_key();
webrtc::PeerConnectionDependencies dependencies(nullptr);
PeerConnectionDependencies dependencies(nullptr);
dependencies.cert_generator = std::move(cert_generator);
return CreatePeerConnectionWrapper("New Peer", nullptr, nullptr,
std::move(dependencies), nullptr,
@ -1606,12 +1599,12 @@ class PeerConnectionIntegrationBaseTest : public ::testing::Test {
bool CreateOneDirectionalPeerConnectionWrappers(bool caller_to_callee) {
caller_ = CreatePeerConnectionWrapper(
"Caller", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
"Caller", nullptr, nullptr, PeerConnectionDependencies(nullptr),
nullptr,
/*reset_encoder_factory=*/!caller_to_callee,
/*reset_decoder_factory=*/caller_to_callee);
callee_ = CreatePeerConnectionWrapper(
"Callee", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
"Callee", nullptr, nullptr, PeerConnectionDependencies(nullptr),
nullptr,
/*reset_encoder_factory=*/caller_to_callee,
/*reset_decoder_factory=*/!caller_to_callee);
@ -1619,18 +1612,18 @@ class PeerConnectionIntegrationBaseTest : public ::testing::Test {
}
bool CreatePeerConnectionWrappersWithoutMediaEngine() {
caller_ = CreatePeerConnectionWrapper(
"Caller", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false,
/*create_media_engine=*/false);
callee_ = CreatePeerConnectionWrapper(
"Callee", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false,
/*create_media_engine=*/false);
caller_ = CreatePeerConnectionWrapper("Caller", nullptr, nullptr,
PeerConnectionDependencies(nullptr),
nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false,
/*create_media_engine=*/false);
callee_ = CreatePeerConnectionWrapper("Callee", nullptr, nullptr,
PeerConnectionDependencies(nullptr),
nullptr,
/*reset_encoder_factory=*/false,
/*reset_decoder_factory=*/false,
/*create_media_engine=*/false);
return caller_ && callee_;
}
@ -1700,7 +1693,7 @@ class PeerConnectionIntegrationBaseTest : public ::testing::Test {
// Messages may get lost on the unreliable DataChannel, so we send multiple
// times to avoid test flakiness.
void SendRtpDataWithRetries(webrtc::DataChannelInterface* dc,
void SendRtpDataWithRetries(DataChannelInterface* dc,
const std::string& data,
int retries) {
for (int i = 0; i < retries; ++i) {

19
pc/test/mock_peer_connection_observers.h
View File

@ -254,7 +254,7 @@ class MockPeerConnectionObserver : public PeerConnectionObserver {
};
class MockCreateSessionDescriptionObserver
: public webrtc::CreateSessionDescriptionObserver {
: public CreateSessionDescriptionObserver {
public:
MockCreateSessionDescriptionObserver()
: called_(false),
@ -266,7 +266,7 @@ class MockCreateSessionDescriptionObserver
error_ = "";
desc_.reset(desc);
}
void OnFailure(webrtc::RTCError error) override {
void OnFailure(RTCError error) override {
MutexLock lock(&mutex_);
called_ = true;
error_ = error.message();
@ -295,8 +295,7 @@ class MockCreateSessionDescriptionObserver
std::unique_ptr<SessionDescriptionInterface> desc_ RTC_GUARDED_BY(mutex_);
};
class MockSetSessionDescriptionObserver
: public webrtc::SetSessionDescriptionObserver {
class MockSetSessionDescriptionObserver : public SetSessionDescriptionObserver {
public:
static rtc::scoped_refptr<MockSetSessionDescriptionObserver> Create() {
return rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
@ -312,7 +311,7 @@ class MockSetSessionDescriptionObserver
called_ = true;
error_ = "";
}
void OnFailure(webrtc::RTCError error) override {
void OnFailure(RTCError error) override {
MutexLock lock(&mutex_);
called_ = true;
error_ = error.message();
@ -375,14 +374,14 @@ class FakeSetRemoteDescriptionObserver
absl::optional<RTCError> error_;
};
class MockDataChannelObserver : public webrtc::DataChannelObserver {
class MockDataChannelObserver : public DataChannelObserver {
public:
struct Message {
std::string data;
bool binary;
};
explicit MockDataChannelObserver(webrtc::DataChannelInterface* channel)
explicit MockDataChannelObserver(DataChannelInterface* channel)
: channel_(channel) {
channel_->RegisterObserver(this);
states_.push_back(channel_->state());
@ -419,12 +418,12 @@ class MockDataChannelObserver : public webrtc::DataChannelObserver {
}
private:
rtc::scoped_refptr<webrtc::DataChannelInterface> channel_;
rtc::scoped_refptr<DataChannelInterface> channel_;
std::vector<DataChannelInterface::DataState> states_;
std::vector<Message> messages_;
};
class MockStatsObserver : public webrtc::StatsObserver {
class MockStatsObserver : public StatsObserver {
public:
MockStatsObserver() : called_(false), stats_() {}
virtual ~MockStatsObserver() {}
@ -576,7 +575,7 @@ class MockStatsObserver : public webrtc::StatsObserver {
};
// Helper class that just stores the report from the callback.
class MockRTCStatsCollectorCallback : public webrtc::RTCStatsCollectorCallback {
class MockRTCStatsCollectorCallback : public RTCStatsCollectorCallback {
public:
rtc::scoped_refptr<const RTCStatsReport> report() { return report_; }

4
pc/test/rtp_transport_test_util.h
View File

@ -33,9 +33,7 @@ class TransportObserver : public RtpPacketSinkInterface {
rtp_transport->SubscribeReadyToSend(
this, [this](bool arg) { OnReadyToSend(arg); });
rtp_transport->SetUnDemuxableRtpPacketReceivedHandler(
[this](webrtc::RtpPacketReceived& packet) {
OnUndemuxableRtpPacket(packet);
});
[this](RtpPacketReceived& packet) { OnUndemuxableRtpPacket(packet); });
rtp_transport->SubscribeSentPacket(this,
[this](const rtc::SentPacket& packet) {
sent_packet_count_++;

9
pc/test/svc_e2e_tests.cc
View File

@ -160,10 +160,9 @@ std::string SvcTestNameGenerator(
// encoder and decoder level.
class SvcVideoQualityAnalyzer : public DefaultVideoQualityAnalyzer {
public:
using SpatialTemporalLayerCounts =
webrtc::flat_map<int, webrtc::flat_map<int, int>>;
using SpatialTemporalLayerCounts = flat_map<int, flat_map<int, int>>;
explicit SvcVideoQualityAnalyzer(webrtc::Clock* clock)
explicit SvcVideoQualityAnalyzer(Clock* clock)
: DefaultVideoQualityAnalyzer(clock,
test::GetGlobalMetricsLogger(),
DefaultVideoQualityAnalyzerOptions{
@ -315,9 +314,9 @@ TEST_P(SvcTest, ScalabilityModeSupported) {
if (UseDependencyDescriptor()) {
trials += "WebRTC-DependencyDescriptorAdvertised/Enabled/";
}
webrtc::test::ScopedFieldTrials override_trials(AppendFieldTrials(trials));
test::ScopedFieldTrials override_trials(AppendFieldTrials(trials));
std::unique_ptr<NetworkEmulationManager> network_emulation_manager =
CreateNetworkEmulationManager(webrtc::TimeMode::kSimulated);
CreateNetworkEmulationManager(TimeMode::kSimulated);
auto analyzer = std::make_unique<SvcVideoQualityAnalyzer>(
network_emulation_manager->time_controller()->GetClock());
SvcVideoQualityAnalyzer* analyzer_ptr = analyzer.get();

2
pc/video_rtp_receiver_unittest.cc
View File

@ -94,7 +94,7 @@ class VideoRtpReceiverTest : public testing::Test {
[&]() { receiver_->SetMediaChannel(media_channel); });
}
webrtc::VideoTrackSourceInterface* Source() {
VideoTrackSourceInterface* Source() {
return receiver_->streams()[0]->FindVideoTrack("receiver")->GetSource();
}

4
pc/video_rtp_track_source_unittest.cc
View File

@ -109,11 +109,11 @@ TEST(VideoRtpTrackSourceTest, NoCallbacksAfterClearedCallback) {
class TestFrame : public RecordableEncodedFrame {
public:
rtc::scoped_refptr<const webrtc::EncodedImageBufferInterface> encoded_buffer()
rtc::scoped_refptr<const EncodedImageBufferInterface> encoded_buffer()
const override {
return nullptr;
}
absl::optional<webrtc::ColorSpace> color_space() const override {
absl::optional<ColorSpace> color_space() const override {
return absl::nullopt;
}
VideoCodecType codec() const override { return kVideoCodecGeneric; }

2
pc/video_track.h
View File

@ -70,7 +70,7 @@ class VideoTrack : public MediaStreamTrack<VideoTrackInterface>,
// Implements ObserverInterface. Observes `video_source_` state.
void OnChanged() override;
RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker signaling_thread_;
RTC_NO_UNIQUE_ADDRESS SequenceChecker signaling_thread_;
rtc::Thread* const worker_thread_;
const rtc::scoped_refptr<
VideoTrackSourceProxyWithInternal<VideoTrackSourceInterface>>

2
pc/video_track_source_proxy.h
View File

@ -52,7 +52,7 @@ PROXY_SECONDARY_METHOD1(void,
rtc::VideoSinkInterface<RecordableEncodedFrame>*)
PROXY_SECONDARY_METHOD1(void,
ProcessConstraints,
const webrtc::VideoTrackSourceConstraints&)
const VideoTrackSourceConstraints&)
END_PROXY_MAP(VideoTrackSource)
} // namespace webrtc

2
pc/webrtc_sdp.cc
View File

@ -2626,7 +2626,7 @@ static std::unique_ptr<MediaContentDescription> ParseContentDescription(
int* msid_signaling,
TransportDescription* transport,
std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
webrtc::SdpParseError* error) {
SdpParseError* error) {
std::unique_ptr<MediaContentDescription> media_desc;
if (media_type == cricket::MediaType::MEDIA_TYPE_AUDIO) {
media_desc = std::make_unique<AudioContentDescription>();

93
tools_webrtc/remove_extra_namespace.py Executable file
View File

@ -0,0 +1,93 @@
#!/usr/bin/env vpython3
# Copyright (c) 2023 The WebRTC project authors. All Rights Reserved.
#
# Use of this source code is governed by a BSD-style license
# that can be found in the LICENSE file in the root of the source
# tree. An additional intellectual property rights grant can be found
# in the file PATENTS. All contributing project authors may
# be found in the AUTHORS file in the root of the source tree.
"""Remove extra namespace qualifications
Looks for names that don't need to be qualified by namespace, and deletes
the qualifier.
Depends on namespace names being properly formatted
"""
import os
import glob
import sys
import re
import argparse
def remove_extra_namespace_from_file(namespace, filename):
print('Processing namespace', namespace, 'file', filename)
with open(filename) as file:
newfile = open(filename + '.NEW', 'w')
namespaces = []
changes = 0
for line in file:
match = re.match(r'namespace (\S+) {', line)
if match is not None:
namespaces.insert(0, match.group(1))
newfile.write(line)
continue
match = re.match(r'}\s+// namespace (\S+)$', line)
if match is not None:
if match.group(1) != namespaces[0]:
print('Namespace mismatch')
raise RuntimeError('Namespace mismatch')
del namespaces[0]
newfile.write(line)
continue
# Remove namespace usage. Only replacing when target
# namespace is the innermost namespace.
if len(namespaces) > 0 and namespaces[0] == namespace:
# Note that in namespace foo, we match neither ::foo::name
# nor morefoo::name
# Neither do we match foo:: when it is not followed by
# an identifier character.
usage_re = r'(?<=[^a-z:]){}::(?=[a-zA-Z])'.format(
namespaces[0])
if re.search(usage_re, line):
line = re.sub(usage_re, '', line)
changes += 1
newfile.write(line)
if changes > 0:
print('Made', changes, 'changes to', filename)
os.remove(filename)
os.rename(filename + '.NEW', filename)
else:
os.remove(filename + '.NEW')
def remove_extra_namespace_from_files(namespace, files):
for file in files:
if os.path.isfile(file):
if re.search(r'\.(h|cc)$', file):
remove_extra_namespace_from_file(namespace, file)
elif os.path.isdir(file):
if file in ('third_party', 'out'):
continue
subfiles = glob.glob(file + '/*')
remove_extra_namespace_from_files(namespace, subfiles)
else:
print(file, 'is not a file or directory, ignoring')
def main():
parser = argparse.ArgumentParser(
prog='remove_extra_namespace.py',
description=__doc__.strip().splitlines()[0],
epilog=''.join(__doc__.splitlines(True)[1:]),
formatter_class=argparse.RawDescriptionHelpFormatter,
)
parser.add_argument('--namespace')
parser.add_argument('files', nargs=argparse.REMAINDER)
args = parser.parse_args()
return remove_extra_namespace_from_files(args.namespace, args.files)
if __name__ == '__main__':
sys.exit(main())