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( void AudioRtpReceiver::SetDepacketizerToDecoderFrameTransformer(
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) { rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) {
RTC_DCHECK_RUN_ON(worker_thread_); RTC_DCHECK_RUN_ON(worker_thread_);
if (media_channel_) { if (media_channel_) {
media_channel_->SetDepacketizerToDecoderFrameTransformer( 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; std::vector<RtpSource> GetSources() const override;
int AttachmentId() const override { return attachment_id_; } int AttachmentId() const override { return attachment_id_; }
void SetDepacketizerToDecoderFrameTransformer( void SetDepacketizerToDecoderFrameTransformer(
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) override;
override;
private: private:
void RestartMediaChannel(absl::optional<uint32_t> ssrc) 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 // thread when a media channel pointer is passed to the receiver via the
// constructor. // constructor.
TEST(AudioRtpReceiver, OnChangedNotificationsAfterConstruction) { TEST(AudioRtpReceiver, OnChangedNotificationsAfterConstruction) {
webrtc::test::RunLoop loop; test::RunLoop loop;
auto* thread = rtc::Thread::Current(); // Points to loop's thread. auto* thread = rtc::Thread::Current(); // Points to loop's thread.
cricket::MockVoiceMediaReceiveChannelInterface receive_channel; cricket::MockVoiceMediaReceiveChannelInterface receive_channel;
auto receiver = rtc::make_ref_counted<AudioRtpReceiver>( auto receiver = rtc::make_ref_counted<AudioRtpReceiver>(

2
pc/audio_track.h
View File

@ -58,7 +58,7 @@ class AudioTrack : public MediaStreamTrack<AudioTrackInterface>,
private: private:
const rtc::scoped_refptr<AudioSourceInterface> audio_source_; 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 } // namespace webrtc

2
pc/connection_context.h
View File

@ -138,7 +138,7 @@ class ConnectionContext final
RTC_GUARDED_BY(signaling_thread_); RTC_GUARDED_BY(signaling_thread_);
std::unique_ptr<rtc::NetworkManager> default_network_manager_ std::unique_ptr<rtc::NetworkManager> default_network_manager_
RTC_GUARDED_BY(signaling_thread_); 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()); RTC_GUARDED_BY(worker_thread());
std::unique_ptr<rtc::PacketSocketFactory> default_socket_factory_ 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::NiceMock;
using ::testing::Return; using ::testing::Return;
class MockDataChannelTransport : public webrtc::DataChannelTransportInterface { class MockDataChannelTransport : public DataChannelTransportInterface {
public: public:
~MockDataChannelTransport() override {} ~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 // Some things use a time of "0" as a special value, so we need to start out
// the fake clock at a nonzero time. // the fake clock at a nonzero time.
// TODO(deadbeef): Fix this. // TODO(deadbeef): Fix this.
AdvanceTime(webrtc::TimeDelta::Seconds(1)); AdvanceTime(TimeDelta::Seconds(1));
} }
// Explicit handle. // Explicit handle.
@ -422,7 +422,7 @@ TEST_P(DataChannelIntegrationTest, CalleeClosesSctpDataChannel) {
TEST_P(DataChannelIntegrationTest, SctpDataChannelConfigSentToOtherSide) { TEST_P(DataChannelIntegrationTest, SctpDataChannelConfigSentToOtherSide) {
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
webrtc::DataChannelInit init; DataChannelInit init;
init.id = 53; init.id = 53;
init.maxRetransmits = 52; init.maxRetransmits = 52;
caller()->CreateDataChannel("data-channel", &init); caller()->CreateDataChannel("data-channel", &init);
@ -453,7 +453,7 @@ TEST_P(DataChannelIntegrationTest, StressTestUnorderedSctpDataChannel) {
// Normal procedure, but with unordered data channel config. // Normal procedure, but with unordered data channel config.
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
webrtc::DataChannelInit init; DataChannelInit init;
init.ordered = false; init.ordered = false;
caller()->CreateDataChannel(&init); caller()->CreateDataChannel(&init);
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
@ -515,7 +515,7 @@ TEST_P(DataChannelIntegrationTest, StressTestOpenCloseChannelNoDelay) {
const size_t kIterations = 10; const size_t kIterations = 10;
bool has_negotiated = false; bool has_negotiated = false;
webrtc::DataChannelInit init; DataChannelInit init;
for (size_t repeats = 0; repeats < kIterations; ++repeats) { for (size_t repeats = 0; repeats < kIterations; ++repeats) {
RTC_LOG(LS_INFO) << "Iteration " << (repeats + 1) << "/" << kIterations; RTC_LOG(LS_INFO) << "Iteration " << (repeats + 1) << "/" << kIterations;
@ -592,7 +592,7 @@ TEST_P(DataChannelIntegrationTest, StressTestOpenCloseChannelWithDelay) {
const size_t kIterations = 10; const size_t kIterations = 10;
bool has_negotiated = false; bool has_negotiated = false;
webrtc::DataChannelInit init; DataChannelInit init;
for (size_t repeats = 0; repeats < kIterations; ++repeats) { for (size_t repeats = 0; repeats < kIterations; ++repeats) {
RTC_LOG(LS_INFO) << "Iteration " << (repeats + 1) << "/" << kIterations; 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_)) { controller_(new FakeDataChannelController(&network_thread_)) {
network_thread_.Start(); network_thread_.Start();
inner_channel_ = controller_->CreateDataChannel("test", init_); inner_channel_ = controller_->CreateDataChannel("test", init_);
channel_ = channel_ = SctpDataChannel::CreateProxy(inner_channel_, signaling_safety_);
webrtc::SctpDataChannel::CreateProxy(inner_channel_, signaling_safety_);
} }
~SctpDataChannelTest() override { ~SctpDataChannelTest() override {
run_loop_.Flush(); run_loop_.Flush();
@ -510,7 +509,7 @@ TEST_F(SctpDataChannelTest, LateCreatedChannelTransitionToOpen) {
SetChannelReady(); SetChannelReady();
InternalDataChannelInit init; InternalDataChannelInit init;
init.id = 1; init.id = 1;
auto dc = webrtc::SctpDataChannel::CreateProxy( auto dc = SctpDataChannel::CreateProxy(
controller_->CreateDataChannel("test1", init), signaling_safety_); controller_->CreateDataChannel("test1", init), signaling_safety_);
EXPECT_EQ(DataChannelInterface::kOpen, dc->state()); EXPECT_EQ(DataChannelInterface::kOpen, dc->state());
} }
@ -524,7 +523,7 @@ TEST_F(SctpDataChannelTest, SendUnorderedAfterReceivesOpenAck) {
init.ordered = false; init.ordered = false;
rtc::scoped_refptr<SctpDataChannel> dc = rtc::scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", init); 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); EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
@ -553,7 +552,7 @@ TEST_F(SctpDataChannelTest, DeprecatedSendUnorderedAfterReceivesOpenAck) {
init.ordered = false; init.ordered = false;
rtc::scoped_refptr<SctpDataChannel> dc = rtc::scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", init); 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); EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
@ -582,7 +581,7 @@ TEST_F(SctpDataChannelTest, SendUnorderedAfterReceiveData) {
init.ordered = false; init.ordered = false;
rtc::scoped_refptr<SctpDataChannel> dc = rtc::scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", init); 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); EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
@ -605,7 +604,7 @@ TEST_F(SctpDataChannelTest, DeprecatedSendUnorderedAfterReceiveData) {
init.ordered = false; init.ordered = false;
rtc::scoped_refptr<SctpDataChannel> dc = rtc::scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", init); 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); EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
@ -714,7 +713,7 @@ TEST_F(SctpDataChannelTest, NoMsgSentIfNegotiatedAndNotFromOpenMsg) {
SetChannelReady(); SetChannelReady();
rtc::scoped_refptr<SctpDataChannel> dc = rtc::scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", config); 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_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
EXPECT_EQ(0, controller_->last_sid()); EXPECT_EQ(0, controller_->last_sid());
@ -779,7 +778,7 @@ TEST_F(SctpDataChannelTest, OpenAckSentIfCreatedFromOpenMessage) {
SetChannelReady(); SetChannelReady();
rtc::scoped_refptr<SctpDataChannel> dc = rtc::scoped_refptr<SctpDataChannel> dc =
controller_->CreateDataChannel("test1", config); 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_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.tls_cert_policy = tls_certificate_policy;
server.hostname = hostname; server.hostname = hostname;
servers.push_back(server); servers.push_back(server);
return webrtc::ParseIceServersOrError(servers, &stun_servers_, return ParseIceServersOrError(servers, &stun_servers_, &turn_servers_).ok();
&turn_servers_)
.ok();
} }
protected: protected:
@ -233,8 +231,7 @@ TEST_F(IceServerParsingTest, ParseMultipleUrls) {
server.password = "bar"; server.password = "bar";
servers.push_back(server); servers.push_back(server);
EXPECT_TRUE( EXPECT_TRUE(
webrtc::ParseIceServersOrError(servers, &stun_servers_, &turn_servers_) ParseIceServersOrError(servers, &stun_servers_, &turn_servers_).ok());
.ok());
EXPECT_EQ(1U, stun_servers_.size()); EXPECT_EQ(1U, stun_servers_.size());
EXPECT_EQ(1U, turn_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(); } rtc::SocketServer* socket_server() const { return socket_server_.get(); }
webrtc::test::ScopedKeyValueConfig field_trials_; test::ScopedKeyValueConfig field_trials_;
private: private:
std::unique_ptr<rtc::SocketServer> socket_server_; 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(); return jsep_transport->rtcp_dtls_transport();
} }
rtc::scoped_refptr<webrtc::DtlsTransport> rtc::scoped_refptr<DtlsTransport>
JsepTransportController::LookupDtlsTransportByMid(const std::string& mid) { JsepTransportController::LookupDtlsTransportByMid(const std::string& mid) {
RTC_DCHECK_RUN_ON(network_thread_); RTC_DCHECK_RUN_ON(network_thread_);
auto jsep_transport = GetJsepTransportForMid(mid); auto jsep_transport = GetJsepTransportForMid(mid);
@ -383,7 +383,7 @@ RTCError JsepTransportController::RollbackTransports() {
return RTCError::OK(); return RTCError::OK();
} }
rtc::scoped_refptr<webrtc::IceTransportInterface> rtc::scoped_refptr<IceTransportInterface>
JsepTransportController::CreateIceTransport(const std::string& transport_name, JsepTransportController::CreateIceTransport(const std::string& transport_name,
bool rtcp) { bool rtcp) {
int component = rtcp ? cricket::ICE_CANDIDATE_COMPONENT_RTCP int component = rtcp ? cricket::ICE_CANDIDATE_COMPONENT_RTCP
@ -455,7 +455,7 @@ JsepTransportController::CreateDtlsTransport(
return dtls; return dtls;
} }
std::unique_ptr<webrtc::RtpTransport> std::unique_ptr<RtpTransport>
JsepTransportController::CreateUnencryptedRtpTransport( JsepTransportController::CreateUnencryptedRtpTransport(
const std::string& transport_name, const std::string& transport_name,
rtc::PacketTransportInternal* rtp_packet_transport, rtc::PacketTransportInternal* rtp_packet_transport,
@ -470,13 +470,12 @@ JsepTransportController::CreateUnencryptedRtpTransport(
return unencrypted_rtp_transport; return unencrypted_rtp_transport;
} }
std::unique_ptr<webrtc::SrtpTransport> std::unique_ptr<SrtpTransport> JsepTransportController::CreateSdesTransport(
JsepTransportController::CreateSdesTransport(
const std::string& transport_name, const std::string& transport_name,
cricket::DtlsTransportInternal* rtp_dtls_transport, cricket::DtlsTransportInternal* rtp_dtls_transport,
cricket::DtlsTransportInternal* rtcp_dtls_transport) { cricket::DtlsTransportInternal* rtcp_dtls_transport) {
RTC_DCHECK_RUN_ON(network_thread_); 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); rtcp_dtls_transport == nullptr, *config_.field_trials);
RTC_DCHECK(rtp_dtls_transport); RTC_DCHECK(rtp_dtls_transport);
srtp_transport->SetRtpPacketTransport(rtp_dtls_transport); srtp_transport->SetRtpPacketTransport(rtp_dtls_transport);
@ -489,13 +488,13 @@ JsepTransportController::CreateSdesTransport(
return srtp_transport; return srtp_transport;
} }
std::unique_ptr<webrtc::DtlsSrtpTransport> std::unique_ptr<DtlsSrtpTransport>
JsepTransportController::CreateDtlsSrtpTransport( JsepTransportController::CreateDtlsSrtpTransport(
const std::string& transport_name, const std::string& transport_name,
cricket::DtlsTransportInternal* rtp_dtls_transport, cricket::DtlsTransportInternal* rtp_dtls_transport,
cricket::DtlsTransportInternal* rtcp_dtls_transport) { cricket::DtlsTransportInternal* rtcp_dtls_transport) {
RTC_DCHECK_RUN_ON(network_thread_); 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); rtcp_dtls_transport == nullptr, *config_.field_trials);
if (config_.enable_external_auth) { if (config_.enable_external_auth) {
dtls_srtp_transport->EnableExternalAuth(); dtls_srtp_transport->EnableExternalAuth();
@ -985,13 +984,12 @@ int JsepTransportController::GetRtpAbsSendTimeHeaderExtensionId(
const cricket::MediaContentDescription* content_desc = const cricket::MediaContentDescription* content_desc =
content_info.media_description(); content_info.media_description();
const webrtc::RtpExtension* send_time_extension = const RtpExtension* send_time_extension =
webrtc::RtpExtension::FindHeaderExtensionByUri( RtpExtension::FindHeaderExtensionByUri(
content_desc->rtp_header_extensions(), content_desc->rtp_header_extensions(), RtpExtension::kAbsSendTimeUri,
webrtc::RtpExtension::kAbsSendTimeUri,
config_.crypto_options.srtp.enable_encrypted_rtp_header_extensions config_.crypto_options.srtp.enable_encrypted_rtp_header_extensions
? webrtc::RtpExtension::kPreferEncryptedExtension ? RtpExtension::kPreferEncryptedExtension
: webrtc::RtpExtension::kDiscardEncryptedExtension); : RtpExtension::kDiscardEncryptedExtension);
return send_time_extension ? send_time_extension->id : -1; 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."); "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); CreateIceTransport(content_info.name, /*rtcp=*/false);
std::unique_ptr<cricket::DtlsTransportInternal> rtp_dtls_transport = std::unique_ptr<cricket::DtlsTransportInternal> rtp_dtls_transport =
@ -1050,7 +1048,7 @@ RTCError JsepTransportController::MaybeCreateJsepTransport(
std::unique_ptr<SrtpTransport> sdes_transport; std::unique_ptr<SrtpTransport> sdes_transport;
std::unique_ptr<DtlsSrtpTransport> dtls_srtp_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 != if (config_.rtcp_mux_policy !=
PeerConnectionInterface::kRtcpMuxPolicyRequire && PeerConnectionInterface::kRtcpMuxPolicyRequire &&
content_info.type == cricket::MediaProtocolType::kRtp) { content_info.type == cricket::MediaProtocolType::kRtp) {
@ -1096,7 +1094,7 @@ RTCError JsepTransportController::MaybeCreateJsepTransport(
OnRtcpPacketReceived_n(buffer, packet_time_ms); OnRtcpPacketReceived_n(buffer, packet_time_ms);
}); });
jsep_transport->rtp_transport()->SetUnDemuxableRtpPacketReceivedHandler( jsep_transport->rtp_transport()->SetUnDemuxableRtpPacketReceivedHandler(
[this](webrtc::RtpPacketReceived& packet) { [this](RtpPacketReceived& packet) {
RTC_DCHECK_RUN_ON(network_thread_); RTC_DCHECK_RUN_ON(network_thread_);
OnUnDemuxableRtpPacketReceived_n(packet); OnUnDemuxableRtpPacketReceived_n(packet);
}); });
@ -1421,7 +1419,7 @@ void JsepTransportController::OnRtcpPacketReceived_n(
} }
void JsepTransportController::OnUnDemuxableRtpPacketReceived_n( void JsepTransportController::OnUnDemuxableRtpPacketReceived_n(
const webrtc::RtpPacketReceived& packet) { const RtpPacketReceived& packet) {
RTC_DCHECK(config_.un_demuxable_packet_handler); RTC_DCHECK(config_.un_demuxable_packet_handler);
config_.un_demuxable_packet_handler(packet); 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; rtc::SSLProtocolVersion ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
// `crypto_options` is used to determine if created DTLS transports // `crypto_options` is used to determine if created DTLS transports
// negotiate GCM crypto suites or not. // negotiate GCM crypto suites or not.
webrtc::CryptoOptions crypto_options; CryptoOptions crypto_options;
PeerConnectionInterface::BundlePolicy bundle_policy = PeerConnectionInterface::BundlePolicy bundle_policy =
PeerConnectionInterface::kBundlePolicyBalanced; PeerConnectionInterface::kBundlePolicyBalanced;
PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy = PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy =
@ -120,7 +120,7 @@ class JsepTransportController : public sigslot::has_slots<> {
bool disable_encryption = false; bool disable_encryption = false;
bool enable_external_auth = false; bool enable_external_auth = false;
// Used to inject the ICE/DTLS transports created externally. // 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; cricket::DtlsTransportFactory* dtls_transport_factory = nullptr;
Observer* transport_observer = nullptr; Observer* transport_observer = nullptr;
// Must be provided and valid for the lifetime of the // 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_; std::function<void(rtc::SSLHandshakeError)> on_dtls_handshake_error_;
// Field trials. // Field trials.
const webrtc::FieldTrialsView* field_trials; const FieldTrialsView* field_trials;
}; };
// The ICE related events are fired on the `network_thread`. // 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 cricket::DtlsTransportInternal* GetRtcpDtlsTransport(
const std::string& mid) const; const std::string& mid) const;
// Gets the externally sharable version of the DtlsTransport. // Gets the externally sharable version of the DtlsTransport.
rtc::scoped_refptr<webrtc::DtlsTransport> LookupDtlsTransportByMid( rtc::scoped_refptr<DtlsTransport> LookupDtlsTransportByMid(
const std::string& mid); const std::string& mid);
rtc::scoped_refptr<SctpTransport> GetSctpTransport( rtc::scoped_refptr<SctpTransport> GetSctpTransport(
const std::string& mid) const; const std::string& mid) const;
@ -399,19 +399,19 @@ class JsepTransportController : public sigslot::has_slots<> {
std::unique_ptr<cricket::DtlsTransportInternal> CreateDtlsTransport( std::unique_ptr<cricket::DtlsTransportInternal> CreateDtlsTransport(
const cricket::ContentInfo& content_info, const cricket::ContentInfo& content_info,
cricket::IceTransportInternal* ice); cricket::IceTransportInternal* ice);
rtc::scoped_refptr<webrtc::IceTransportInterface> CreateIceTransport( rtc::scoped_refptr<IceTransportInterface> CreateIceTransport(
const std::string& transport_name, const std::string& transport_name,
bool rtcp); bool rtcp);
std::unique_ptr<webrtc::RtpTransport> CreateUnencryptedRtpTransport( std::unique_ptr<RtpTransport> CreateUnencryptedRtpTransport(
const std::string& transport_name, const std::string& transport_name,
rtc::PacketTransportInternal* rtp_packet_transport, rtc::PacketTransportInternal* rtp_packet_transport,
rtc::PacketTransportInternal* rtcp_packet_transport); rtc::PacketTransportInternal* rtcp_packet_transport);
std::unique_ptr<webrtc::SrtpTransport> CreateSdesTransport( std::unique_ptr<SrtpTransport> CreateSdesTransport(
const std::string& transport_name, const std::string& transport_name,
cricket::DtlsTransportInternal* rtp_dtls_transport, cricket::DtlsTransportInternal* rtp_dtls_transport,
cricket::DtlsTransportInternal* rtcp_dtls_transport); cricket::DtlsTransportInternal* rtcp_dtls_transport);
std::unique_ptr<webrtc::DtlsSrtpTransport> CreateDtlsSrtpTransport( std::unique_ptr<DtlsSrtpTransport> CreateDtlsSrtpTransport(
const std::string& transport_name, const std::string& transport_name,
cricket::DtlsTransportInternal* rtp_dtls_transport, cricket::DtlsTransportInternal* rtp_dtls_transport,
cricket::DtlsTransportInternal* rtcp_dtls_transport); cricket::DtlsTransportInternal* rtcp_dtls_transport);
@ -453,7 +453,7 @@ class JsepTransportController : public sigslot::has_slots<> {
void OnRtcpPacketReceived_n(rtc::CopyOnWriteBuffer* packet, void OnRtcpPacketReceived_n(rtc::CopyOnWriteBuffer* packet,
int64_t packet_time_us) int64_t packet_time_us)
RTC_RUN_ON(network_thread_); RTC_RUN_ON(network_thread_);
void OnUnDemuxableRtpPacketReceived_n(const webrtc::RtpPacketReceived& packet) void OnUnDemuxableRtpPacketReceived_n(const RtpPacketReceived& packet)
RTC_RUN_ON(network_thread_); RTC_RUN_ON(network_thread_);
void OnDtlsHandshakeError(rtc::SSLHandshakeError error); 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 { namespace webrtc {
class FakeIceTransportFactory : public webrtc::IceTransportFactory { class FakeIceTransportFactory : public IceTransportFactory {
public: public:
~FakeIceTransportFactory() override = default; ~FakeIceTransportFactory() override = default;
rtc::scoped_refptr<IceTransportInterface> CreateIceTransport( rtc::scoped_refptr<IceTransportInterface> CreateIceTransport(
@ -72,7 +72,7 @@ class FakeDtlsTransportFactory : public cricket::DtlsTransportFactory {
public: public:
std::unique_ptr<cricket::DtlsTransportInternal> CreateDtlsTransport( std::unique_ptr<cricket::DtlsTransportInternal> CreateDtlsTransport(
cricket::IceTransportInternal* ice, cricket::IceTransportInternal* ice,
const webrtc::CryptoOptions& crypto_options, const CryptoOptions& crypto_options,
rtc::SSLProtocolVersion max_version) override { rtc::SSLProtocolVersion max_version) override {
return std::make_unique<FakeDtlsTransport>( return std::make_unique<FakeDtlsTransport>(
static_cast<cricket::FakeIceTransport*>(ice)); 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 // Transport controller needs to be destroyed first, because it may issue
// callbacks that modify the changed_*_by_mid in the destructor. // callbacks that modify the changed_*_by_mid in the destructor.
std::unique_ptr<JsepTransportController> transport_controller_; std::unique_ptr<JsepTransportController> transport_controller_;
webrtc::test::ScopedKeyValueConfig field_trials_; test::ScopedKeyValueConfig field_trials_;
}; };
TEST_F(JsepTransportControllerTest, GetRtpTransport) { TEST_F(JsepTransportControllerTest, GetRtpTransport) {
@ -425,7 +425,7 @@ TEST_F(JsepTransportControllerTest, GetDtlsTransport) {
// and verify that the resulting container is empty. // and verify that the resulting container is empty.
auto dtls_transport = auto dtls_transport =
transport_controller_->LookupDtlsTransportByMid(kVideoMid1); transport_controller_->LookupDtlsTransportByMid(kVideoMid1);
webrtc::DtlsTransport* my_transport = DtlsTransport* my_transport =
static_cast<DtlsTransport*>(dtls_transport.get()); static_cast<DtlsTransport*>(dtls_transport.get());
EXPECT_NE(nullptr, my_transport->internal()); EXPECT_NE(nullptr, my_transport->internal());
transport_controller_.reset(); transport_controller_.reset();
@ -899,7 +899,7 @@ TEST_F(JsepTransportControllerTest,
transport_controller_->GetDtlsTransport(kAudioMid1)); transport_controller_->GetDtlsTransport(kAudioMid1));
fake_audio_dtls->fake_ice_transport()->MaybeStartGathering(); fake_audio_dtls->fake_ice_transport()->MaybeStartGathering();
fake_audio_dtls->fake_ice_transport()->SetTransportState( fake_audio_dtls->fake_ice_transport()->SetTransportState(
webrtc::IceTransportState::kChecking, IceTransportState::kChecking,
cricket::IceTransportState::STATE_CONNECTING); cricket::IceTransportState::STATE_CONNECTING);
EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionChecking, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionChecking,
ice_connection_state_, kTimeout); 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, report->AddInt64(StatsReport::kStatsValueNameInterframeDelayMaxMs,
info.interframe_delay_max_ms); info.interframe_delay_max_ms);
report->AddString( report->AddString(StatsReport::kStatsValueNameContentType,
StatsReport::kStatsValueNameContentType, videocontenttypehelpers::ToString(info.content_type));
webrtc::videocontenttypehelpers::ToString(info.content_type));
} }
void ExtractStats(const cricket::VideoSenderInfo& info, void ExtractStats(const cricket::VideoSenderInfo& info,
@ -398,9 +397,8 @@ void ExtractStats(const cricket::VideoSenderInfo& info,
for (const auto& i : ints) for (const auto& i : ints)
report->AddInt(i.name, i.value); report->AddInt(i.name, i.value);
report->AddString(StatsReport::kStatsValueNameMediaType, "video"); report->AddString(StatsReport::kStatsValueNameMediaType, "video");
report->AddString( report->AddString(StatsReport::kStatsValueNameContentType,
StatsReport::kStatsValueNameContentType, videocontenttypehelpers::ToString(info.content_type));
webrtc::videocontenttypehelpers::ToString(info.content_type));
} }
void ExtractStats(const cricket::BandwidthEstimationInfo& info, void ExtractStats(const cricket::BandwidthEstimationInfo& info,
@ -1033,7 +1031,7 @@ void LegacyStatsCollector::ExtractBweInfo() {
if (pc_->signaling_state() == PeerConnectionInterface::kClosed) if (pc_->signaling_state() == PeerConnectionInterface::kClosed)
return; return;
webrtc::Call::Stats call_stats = pc_->GetCallStats(); Call::Stats call_stats = pc_->GetCallStats();
cricket::BandwidthEstimationInfo bwe_info; cricket::BandwidthEstimationInfo bwe_info;
bwe_info.available_send_bandwidth = call_stats.send_bandwidth_bps; bwe_info.available_send_bandwidth = call_stats.send_bandwidth_bps;
bwe_info.available_recv_bandwidth = call_stats.recv_bandwidth_bps; bwe_info.available_recv_bandwidth = call_stats.recv_bandwidth_bps;

2
pc/legacy_stats_collector.h
View File

@ -177,7 +177,7 @@ class LegacyStatsCollector : public LegacyStatsCollectorInterface {
void ExtractMediaInfo( void ExtractMediaInfo(
const std::map<std::string, std::string>& transport_names_by_mid); const std::map<std::string, std::string>& transport_names_by_mid);
void ExtractSenderInfo(); void ExtractSenderInfo();
webrtc::StatsReport* GetReport(const StatsReport::StatsType& type, StatsReport* GetReport(const StatsReport::StatsType& type,
const std::string& id, const std::string& id,
StatsReport::Direction direction); StatsReport::Direction direction);

10
pc/media_stream_unittest.cc
View File

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

12
pc/peer_connection.cc
View File

@ -185,7 +185,7 @@ IceCandidatePairType GetIceCandidatePairCounter(
absl::optional<int> RTCConfigurationToIceConfigOptionalInt( absl::optional<int> RTCConfigurationToIceConfigOptionalInt(
int rtc_configuration_parameter) { int rtc_configuration_parameter) {
if (rtc_configuration_parameter == if (rtc_configuration_parameter ==
webrtc::PeerConnectionInterface::RTCConfiguration::kUndefined) { PeerConnectionInterface::RTCConfiguration::kUndefined) {
return absl::nullopt; return absl::nullopt;
} }
return rtc_configuration_parameter; return rtc_configuration_parameter;
@ -449,7 +449,7 @@ bool PeerConnectionInterface::RTCConfiguration::operator==(
absl::optional<int> ice_unwritable_min_checks; absl::optional<int> ice_unwritable_min_checks;
absl::optional<int> ice_inactive_timeout; absl::optional<int> ice_inactive_timeout;
absl::optional<int> stun_candidate_keepalive_interval; absl::optional<int> stun_candidate_keepalive_interval;
webrtc::TurnCustomizer* turn_customizer; TurnCustomizer* turn_customizer;
SdpSemantics sdp_semantics; SdpSemantics sdp_semantics;
absl::optional<rtc::AdapterType> network_preference; absl::optional<rtc::AdapterType> network_preference;
bool active_reset_srtp_params; bool active_reset_srtp_params;
@ -459,7 +459,7 @@ bool PeerConnectionInterface::RTCConfiguration::operator==(
bool enable_implicit_rollback; bool enable_implicit_rollback;
absl::optional<int> report_usage_pattern_delay_ms; absl::optional<int> report_usage_pattern_delay_ms;
absl::optional<int> stable_writable_connection_ping_interval_ms; absl::optional<int> stable_writable_connection_ping_interval_ms;
webrtc::VpnPreference vpn_preference; VpnPreference vpn_preference;
std::vector<rtc::NetworkMask> vpn_list; std::vector<rtc::NetworkMask> vpn_list;
PortAllocatorConfig port_allocator_config; PortAllocatorConfig port_allocator_config;
absl::optional<TimeDelta> pacer_burst_interval; absl::optional<TimeDelta> pacer_burst_interval;
@ -1685,7 +1685,7 @@ void PeerConnection::AddIceCandidate(
std::function<void(RTCError)> callback) { std::function<void(RTCError)> callback) {
RTC_DCHECK_RUN_ON(signaling_thread()); RTC_DCHECK_RUN_ON(signaling_thread());
sdp_handler_->AddIceCandidate(std::move(candidate), sdp_handler_->AddIceCandidate(std::move(candidate),
[this, callback](webrtc::RTCError result) { [this, callback](RTCError result) {
ClearStatsCache(); ClearStatsCache();
callback(result); callback(result);
}); });
@ -1789,7 +1789,7 @@ bool PeerConnection::StartRtcEventLog(
std::unique_ptr<RtcEventLogOutput> output) { std::unique_ptr<RtcEventLogOutput> output) {
int64_t output_period_ms = 5000; int64_t output_period_ms = 5000;
if (trials().IsDisabled("WebRTC-RtcEventLogNewFormat")) { if (trials().IsDisabled("WebRTC-RtcEventLogNewFormat")) {
output_period_ms = webrtc::RtcEventLog::kImmediateOutput; output_period_ms = RtcEventLog::kImmediateOutput;
} }
return StartRtcEventLog(std::move(output), output_period_ms); return StartRtcEventLog(std::move(output), output_period_ms);
} }
@ -2222,7 +2222,7 @@ bool PeerConnection::ReconfigurePortAllocator_n(
IceTransportsType type, IceTransportsType type,
int candidate_pool_size, int candidate_pool_size,
PortPrunePolicy turn_port_prune_policy, PortPrunePolicy turn_port_prune_policy,
webrtc::TurnCustomizer* turn_customizer, TurnCustomizer* turn_customizer,
absl::optional<int> stun_candidate_keepalive_interval, absl::optional<int> stun_candidate_keepalive_interval,
bool have_local_description) { bool have_local_description) {
RTC_DCHECK_RUN_ON(network_thread()); 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; const DataChannelInit* config) override;
// WARNING: LEGACY. See peerconnectioninterface.h // WARNING: LEGACY. See peerconnectioninterface.h
bool GetStats(StatsObserver* observer, bool GetStats(StatsObserver* observer,
webrtc::MediaStreamTrackInterface* track, MediaStreamTrackInterface* track,
StatsOutputLevel level) override; StatsOutputLevel level) override;
// Spec-complaint GetStats(). See peerconnectioninterface.h // Spec-complaint GetStats(). See peerconnectioninterface.h
void GetStats(RTCStatsCollectorCallback* callback) override; void GetStats(RTCStatsCollectorCallback* callback) override;
@ -510,7 +510,7 @@ class PeerConnection : public PeerConnectionInternal,
IceTransportsType type, IceTransportsType type,
int candidate_pool_size, int candidate_pool_size,
PortPrunePolicy turn_port_prune_policy, PortPrunePolicy turn_port_prune_policy,
webrtc::TurnCustomizer* turn_customizer, TurnCustomizer* turn_customizer,
absl::optional<int> stun_candidate_keepalive_interval, absl::optional<int> stun_candidate_keepalive_interval,
bool have_local_description); bool have_local_description);
@ -602,7 +602,7 @@ class PeerConnection : public PeerConnectionInternal,
// a) Specified in PeerConnectionDependencies (owned). // a) Specified in PeerConnectionDependencies (owned).
// b) Accessed via ConnectionContext (e.g PeerConnectionFactoryDependencies> // b) Accessed via ConnectionContext (e.g PeerConnectionFactoryDependencies>
// c) Created as Default (FieldTrialBasedConfig). // c) Created as Default (FieldTrialBasedConfig).
const webrtc::AlwaysValidPointer<const FieldTrialsView, FieldTrialBasedConfig> const AlwaysValidPointer<const FieldTrialsView, FieldTrialBasedConfig>
trials_; trials_;
const PeerConnectionFactoryInterface::Options options_; const PeerConnectionFactoryInterface::Options options_;
PeerConnectionObserver* observer_ RTC_GUARDED_BY(signaling_thread()) = PeerConnectionObserver* observer_ RTC_GUARDED_BY(signaling_thread()) =
@ -634,7 +634,7 @@ class PeerConnection : public PeerConnectionInternal,
std::unique_ptr<cricket::PortAllocator> std::unique_ptr<cricket::PortAllocator>
port_allocator_; // TODO(bugs.webrtc.org/9987): Accessed on both port_allocator_; // TODO(bugs.webrtc.org/9987): Accessed on both
// signaling and network thread. // 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 ice_transport_factory_; // TODO(bugs.webrtc.org/9987): Accessed on the
// signaling thread but the underlying raw // signaling thread but the underlying raw
// pointer is given to // 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; return transport_info->description.connection_role;
} }
webrtc::test::ScopedKeyValueConfig field_trials_; test::ScopedKeyValueConfig field_trials_;
std::unique_ptr<rtc::VirtualSocketServer> vss_; std::unique_ptr<rtc::VirtualSocketServer> vss_;
rtc::AutoSocketServerThread main_; rtc::AutoSocketServerThread main_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_; rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;

210
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 // 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 // codecs, but are not themselves a specific codec. Typically you don't want to
// filter these out of the list of codec preferences. // 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) || return absl::EqualsIgnoreCase(codec.name, cricket::kRtxCodecName) ||
absl::EqualsIgnoreCase(codec.name, cricket::kRedCodecName) || absl::EqualsIgnoreCase(codec.name, cricket::kRedCodecName) ||
absl::EqualsIgnoreCase(codec.name, cricket::kUlpfecCodecName); absl::EqualsIgnoreCase(codec.name, cricket::kUlpfecCodecName);
} }
std::string GetCurrentCodecMimeType( std::string GetCurrentCodecMimeType(
rtc::scoped_refptr<const webrtc::RTCStatsReport> report, rtc::scoped_refptr<const RTCStatsReport> report,
const webrtc::RTCOutboundRtpStreamStats& outbound_rtp) { const RTCOutboundRtpStreamStats& outbound_rtp) {
return outbound_rtp.codec_id.is_defined() return outbound_rtp.codec_id.is_defined()
? *report->GetAs<webrtc::RTCCodecStats>(*outbound_rtp.codec_id) ? *report->GetAs<RTCCodecStats>(*outbound_rtp.codec_id)->mime_type
->mime_type
: ""; : "";
} }
@ -98,8 +97,8 @@ struct RidAndResolution {
uint32_t height; uint32_t height;
}; };
const webrtc::RTCOutboundRtpStreamStats* FindOutboundRtpByRid( const RTCOutboundRtpStreamStats* FindOutboundRtpByRid(
const std::vector<const webrtc::RTCOutboundRtpStreamStats*>& outbound_rtps, const std::vector<const RTCOutboundRtpStreamStats*>& outbound_rtps,
const absl::string_view& rid) { const absl::string_view& rid) {
for (const auto* outbound_rtp : outbound_rtps) { for (const auto* outbound_rtp : outbound_rtps) {
if (outbound_rtp->rid.is_defined() && *outbound_rtp->rid == rid) { if (outbound_rtp->rid.is_defined() && *outbound_rtp->rid == rid) {
@ -121,8 +120,8 @@ class PeerConnectionEncodingsIntegrationTest : public ::testing::Test {
rtc::scoped_refptr<PeerConnectionTestWrapper> CreatePc() { rtc::scoped_refptr<PeerConnectionTestWrapper> CreatePc() {
auto pc_wrapper = rtc::make_ref_counted<PeerConnectionTestWrapper>( auto pc_wrapper = rtc::make_ref_counted<PeerConnectionTestWrapper>(
"pc", &pss_, background_thread_.get(), background_thread_.get()); "pc", &pss_, background_thread_.get(), background_thread_.get());
pc_wrapper->CreatePc({}, webrtc::CreateBuiltinAudioEncoderFactory(), pc_wrapper->CreatePc({}, CreateBuiltinAudioEncoderFactory(),
webrtc::CreateBuiltinAudioDecoderFactory()); CreateBuiltinAudioDecoderFactory());
return pc_wrapper; return pc_wrapper;
} }
@ -130,8 +129,7 @@ class PeerConnectionEncodingsIntegrationTest : public ::testing::Test {
rtc::scoped_refptr<PeerConnectionTestWrapper> local, rtc::scoped_refptr<PeerConnectionTestWrapper> local,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote, rtc::scoped_refptr<PeerConnectionTestWrapper> remote,
std::vector<cricket::SimulcastLayer> init_layers) { std::vector<cricket::SimulcastLayer> init_layers) {
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream = rtc::scoped_refptr<MediaStreamInterface> stream = local->GetUserMedia(
local->GetUserMedia(
/*audio=*/false, cricket::AudioOptions(), /*video=*/true, /*audio=*/false, cricket::AudioOptions(), /*video=*/true,
{.width = 1280, .height = 720}); {.width = 1280, .height = 720});
rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0]; rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
@ -973,8 +971,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->pc()->AddTransceiver(cricket::MEDIA_TYPE_AUDIO); local_pc_wrapper->pc()->AddTransceiver(cricket::MEDIA_TYPE_AUDIO);
rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver = rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue(); transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters = RtpParameters parameters = audio_transceiver->sender()->GetParameters();
audio_transceiver->sender()->GetParameters();
EXPECT_FALSE(parameters.encodings[0].codec.has_value()); EXPECT_FALSE(parameters.encodings[0].codec.has_value());
} }
@ -986,8 +983,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->pc()->AddTransceiver(cricket::MEDIA_TYPE_VIDEO); local_pc_wrapper->pc()->AddTransceiver(cricket::MEDIA_TYPE_VIDEO);
rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver = rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue(); transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters = RtpParameters parameters = video_transceiver->sender()->GetParameters();
video_transceiver->sender()->GetParameters();
EXPECT_FALSE(parameters.encodings[0].codec.has_value()); EXPECT_FALSE(parameters.encodings[0].codec.has_value());
} }
@ -997,19 +993,19 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper); ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream = rtc::scoped_refptr<MediaStreamInterface> stream =
local_pc_wrapper->GetUserMedia( local_pc_wrapper->GetUserMedia(
/*audio=*/true, {}, /*video=*/false, {}); /*audio=*/true, {}, /*video=*/false, {});
rtc::scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0]; 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, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"pcmu"); "pcmu");
ASSERT_TRUE(pcmu); ASSERT_TRUE(pcmu);
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly; init.direction = RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
encoding_parameters.codec = pcmu; encoding_parameters.codec = pcmu;
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
@ -1017,8 +1013,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->pc()->AddTransceiver(track, init); local_pc_wrapper->pc()->AddTransceiver(track, init);
rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver = rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue(); transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters = RtpParameters parameters = audio_transceiver->sender()->GetParameters();
audio_transceiver->sender()->GetParameters();
EXPECT_EQ(*parameters.encodings[0].codec, *pcmu); EXPECT_EQ(*parameters.encodings[0].codec, *pcmu);
NegotiateWithSimulcastTweaks(local_pc_wrapper, remote_pc_wrapper); NegotiateWithSimulcastTweaks(local_pc_wrapper, remote_pc_wrapper);
@ -1039,19 +1034,19 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper); ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream = rtc::scoped_refptr<MediaStreamInterface> stream =
local_pc_wrapper->GetUserMedia( local_pc_wrapper->GetUserMedia(
/*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720}); /*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720});
rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0]; 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, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp9"); "vp9");
ASSERT_TRUE(vp9); ASSERT_TRUE(vp9);
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly; init.direction = RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
encoding_parameters.codec = vp9; encoding_parameters.codec = vp9;
encoding_parameters.scalability_mode = "L3T3"; encoding_parameters.scalability_mode = "L3T3";
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
@ -1060,8 +1055,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->pc()->AddTransceiver(track, init); local_pc_wrapper->pc()->AddTransceiver(track, init);
rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver = rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue(); transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters = RtpParameters parameters = audio_transceiver->sender()->GetParameters();
audio_transceiver->sender()->GetParameters();
EXPECT_EQ(*parameters.encodings[0].codec, *vp9); EXPECT_EQ(*parameters.encodings[0].codec, *vp9);
NegotiateWithSimulcastTweaks(local_pc_wrapper, remote_pc_wrapper); NegotiateWithSimulcastTweaks(local_pc_wrapper, remote_pc_wrapper);
@ -1087,20 +1081,19 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper); ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream = rtc::scoped_refptr<MediaStreamInterface> stream =
local_pc_wrapper->GetUserMedia( local_pc_wrapper->GetUserMedia(
/*audio=*/true, {}, /*video=*/false, {}); /*audio=*/true, {}, /*video=*/false, {});
rtc::scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0]; 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, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"pcmu"); "pcmu");
auto transceiver_or_error = local_pc_wrapper->pc()->AddTransceiver(track); auto transceiver_or_error = local_pc_wrapper->pc()->AddTransceiver(track);
rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver = rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue(); transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters = RtpParameters parameters = audio_transceiver->sender()->GetParameters();
audio_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = pcmu; parameters.encodings[0].codec = pcmu;
EXPECT_TRUE(audio_transceiver->sender()->SetParameters(parameters).ok()); EXPECT_TRUE(audio_transceiver->sender()->SetParameters(parameters).ok());
@ -1125,12 +1118,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper); ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream = rtc::scoped_refptr<MediaStreamInterface> stream =
local_pc_wrapper->GetUserMedia( local_pc_wrapper->GetUserMedia(
/*audio=*/true, {}, /*video=*/false, {}); /*audio=*/true, {}, /*video=*/false, {});
rtc::scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0]; 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, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"pcmu"); "pcmu");
@ -1150,8 +1143,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
EXPECT_STRCASENE(("audio/" + pcmu->name).c_str(), codec_name.c_str()); EXPECT_STRCASENE(("audio/" + pcmu->name).c_str(), codec_name.c_str());
std::string last_codec_id = outbound_rtps[0]->codec_id.value(); std::string last_codec_id = outbound_rtps[0]->codec_id.value();
webrtc::RtpParameters parameters = RtpParameters parameters = audio_transceiver->sender()->GetParameters();
audio_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = pcmu; parameters.encodings[0].codec = pcmu;
EXPECT_TRUE(audio_transceiver->sender()->SetParameters(parameters).ok()); EXPECT_TRUE(audio_transceiver->sender()->SetParameters(parameters).ok());
@ -1174,20 +1166,19 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper); ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream = rtc::scoped_refptr<MediaStreamInterface> stream =
local_pc_wrapper->GetUserMedia( local_pc_wrapper->GetUserMedia(
/*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720}); /*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720});
rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0]; 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, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp9"); "vp9");
auto transceiver_or_error = local_pc_wrapper->pc()->AddTransceiver(track); auto transceiver_or_error = local_pc_wrapper->pc()->AddTransceiver(track);
rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver = rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue(); transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters = RtpParameters parameters = video_transceiver->sender()->GetParameters();
video_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = vp9; parameters.encodings[0].codec = vp9;
parameters.encodings[0].scalability_mode = "L3T3"; parameters.encodings[0].scalability_mode = "L3T3";
EXPECT_TRUE(video_transceiver->sender()->SetParameters(parameters).ok()); EXPECT_TRUE(video_transceiver->sender()->SetParameters(parameters).ok());
@ -1218,12 +1209,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper); ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream = rtc::scoped_refptr<MediaStreamInterface> stream =
local_pc_wrapper->GetUserMedia( local_pc_wrapper->GetUserMedia(
/*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720}); /*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720});
rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0]; 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, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp9"); "vp9");
@ -1243,8 +1234,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
EXPECT_STRCASENE(("audio/" + vp9->name).c_str(), codec_name.c_str()); EXPECT_STRCASENE(("audio/" + vp9->name).c_str(), codec_name.c_str());
std::string last_codec_id = outbound_rtps[0]->codec_id.value(); std::string last_codec_id = outbound_rtps[0]->codec_id.value();
webrtc::RtpParameters parameters = RtpParameters parameters = video_transceiver->sender()->GetParameters();
video_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = vp9; parameters.encodings[0].codec = vp9;
parameters.encodings[0].scalability_mode = "L3T3"; parameters.encodings[0].scalability_mode = "L3T3";
EXPECT_TRUE(video_transceiver->sender()->SetParameters(parameters).ok()); EXPECT_TRUE(video_transceiver->sender()->SetParameters(parameters).ok());
@ -1269,15 +1259,15 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
AddTransceiverRejectsUnknownCodecParameterAudio) { AddTransceiverRejectsUnknownCodecParameterAudio) {
rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
webrtc::RtpCodec dummy_codec; RtpCodec dummy_codec;
dummy_codec.kind = cricket::MEDIA_TYPE_AUDIO; dummy_codec.kind = cricket::MEDIA_TYPE_AUDIO;
dummy_codec.name = "FOOBAR"; dummy_codec.name = "FOOBAR";
dummy_codec.clock_rate = 90000; dummy_codec.clock_rate = 90000;
dummy_codec.num_channels = 2; dummy_codec.num_channels = 2;
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly; init.direction = RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
encoding_parameters.codec = dummy_codec; encoding_parameters.codec = dummy_codec;
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
@ -1292,14 +1282,14 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
AddTransceiverRejectsUnknownCodecParameterVideo) { AddTransceiverRejectsUnknownCodecParameterVideo) {
rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
webrtc::RtpCodec dummy_codec; RtpCodec dummy_codec;
dummy_codec.kind = cricket::MEDIA_TYPE_VIDEO; dummy_codec.kind = cricket::MEDIA_TYPE_VIDEO;
dummy_codec.name = "FOOBAR"; dummy_codec.name = "FOOBAR";
dummy_codec.clock_rate = 90000; dummy_codec.clock_rate = 90000;
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly; init.direction = RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
encoding_parameters.codec = dummy_codec; encoding_parameters.codec = dummy_codec;
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
@ -1314,7 +1304,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsUnknownCodecParameterAudio) { SetParametersRejectsUnknownCodecParameterAudio) {
rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
webrtc::RtpCodec dummy_codec; RtpCodec dummy_codec;
dummy_codec.kind = cricket::MEDIA_TYPE_AUDIO; dummy_codec.kind = cricket::MEDIA_TYPE_AUDIO;
dummy_codec.name = "FOOBAR"; dummy_codec.name = "FOOBAR";
dummy_codec.clock_rate = 90000; dummy_codec.clock_rate = 90000;
@ -1326,8 +1316,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver = rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
transceiver_or_error.MoveValue(); transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters = RtpParameters parameters = audio_transceiver->sender()->GetParameters();
audio_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = dummy_codec; parameters.encodings[0].codec = dummy_codec;
RTCError error = audio_transceiver->sender()->SetParameters(parameters); RTCError error = audio_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION); EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1337,7 +1326,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsUnknownCodecParameterVideo) { SetParametersRejectsUnknownCodecParameterVideo) {
rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
webrtc::RtpCodec dummy_codec; RtpCodec dummy_codec;
dummy_codec.kind = cricket::MEDIA_TYPE_VIDEO; dummy_codec.kind = cricket::MEDIA_TYPE_VIDEO;
dummy_codec.name = "FOOBAR"; dummy_codec.name = "FOOBAR";
dummy_codec.clock_rate = 90000; dummy_codec.clock_rate = 90000;
@ -1348,8 +1337,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver = rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue(); transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters = RtpParameters parameters = video_transceiver->sender()->GetParameters();
video_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = dummy_codec; parameters.encodings[0].codec = dummy_codec;
RTCError error = video_transceiver->sender()->SetParameters(parameters); RTCError error = video_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION); EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1359,12 +1347,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsNonPreferredCodecParameterAudio) { SetParametersRejectsNonPreferredCodecParameterAudio) {
rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc(); 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, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"opus"); "opus");
ASSERT_TRUE(opus); ASSERT_TRUE(opus);
std::vector<webrtc::RtpCodecCapability> not_opus_codecs = std::vector<RtpCodecCapability> not_opus_codecs =
local_pc_wrapper->pc_factory() local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO) ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
.codecs; .codecs;
@ -1382,8 +1370,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
transceiver_or_error.MoveValue(); transceiver_or_error.MoveValue();
ASSERT_TRUE(audio_transceiver->SetCodecPreferences(not_opus_codecs).ok()); ASSERT_TRUE(audio_transceiver->SetCodecPreferences(not_opus_codecs).ok());
webrtc::RtpParameters parameters = RtpParameters parameters = audio_transceiver->sender()->GetParameters();
audio_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = opus; parameters.encodings[0].codec = opus;
RTCError error = audio_transceiver->sender()->SetParameters(parameters); RTCError error = audio_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION); EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1393,12 +1380,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsNonPreferredCodecParameterVideo) { SetParametersRejectsNonPreferredCodecParameterVideo) {
rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc(); 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, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp8"); "vp8");
ASSERT_TRUE(vp8); ASSERT_TRUE(vp8);
std::vector<webrtc::RtpCodecCapability> not_vp8_codecs = std::vector<RtpCodecCapability> not_vp8_codecs =
local_pc_wrapper->pc_factory() local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO) ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO)
.codecs; .codecs;
@ -1416,8 +1403,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
transceiver_or_error.MoveValue(); transceiver_or_error.MoveValue();
ASSERT_TRUE(video_transceiver->SetCodecPreferences(not_vp8_codecs).ok()); ASSERT_TRUE(video_transceiver->SetCodecPreferences(not_vp8_codecs).ok());
webrtc::RtpParameters parameters = RtpParameters parameters = video_transceiver->sender()->GetParameters();
video_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = vp8; parameters.encodings[0].codec = vp8;
RTCError error = video_transceiver->sender()->SetParameters(parameters); RTCError error = video_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION); EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1429,12 +1415,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper); ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
absl::optional<webrtc::RtpCodecCapability> opus = absl::optional<RtpCodecCapability> opus =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"opus"); "opus");
ASSERT_TRUE(opus); ASSERT_TRUE(opus);
std::vector<webrtc::RtpCodecCapability> not_opus_codecs = std::vector<RtpCodecCapability> not_opus_codecs =
local_pc_wrapper->pc_factory() local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO) ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
.codecs; .codecs;
@ -1456,8 +1442,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->WaitForConnection(); local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection(); remote_pc_wrapper->WaitForConnection();
webrtc::RtpParameters parameters = RtpParameters parameters = audio_transceiver->sender()->GetParameters();
audio_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = opus; parameters.encodings[0].codec = opus;
RTCError error = audio_transceiver->sender()->SetParameters(parameters); RTCError error = audio_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION); EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1469,12 +1454,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper); ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
absl::optional<webrtc::RtpCodecCapability> opus = absl::optional<RtpCodecCapability> opus =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"opus"); "opus");
ASSERT_TRUE(opus); ASSERT_TRUE(opus);
std::vector<webrtc::RtpCodecCapability> not_opus_codecs = std::vector<RtpCodecCapability> not_opus_codecs =
local_pc_wrapper->pc_factory() local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO) ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
.codecs; .codecs;
@ -1519,8 +1504,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->WaitForConnection(); local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection(); remote_pc_wrapper->WaitForConnection();
webrtc::RtpParameters parameters = RtpParameters parameters = audio_transceiver->sender()->GetParameters();
audio_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = opus; parameters.encodings[0].codec = opus;
RTCError error = audio_transceiver->sender()->SetParameters(parameters); RTCError error = audio_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION); EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1532,12 +1516,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper); ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
absl::optional<webrtc::RtpCodecCapability> vp8 = absl::optional<RtpCodecCapability> vp8 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp8"); "vp8");
ASSERT_TRUE(vp8); ASSERT_TRUE(vp8);
std::vector<webrtc::RtpCodecCapability> not_vp8_codecs = std::vector<RtpCodecCapability> not_vp8_codecs =
local_pc_wrapper->pc_factory() local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO) ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO)
.codecs; .codecs;
@ -1559,8 +1543,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->WaitForConnection(); local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection(); remote_pc_wrapper->WaitForConnection();
webrtc::RtpParameters parameters = RtpParameters parameters = video_transceiver->sender()->GetParameters();
video_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = vp8; parameters.encodings[0].codec = vp8;
RTCError error = video_transceiver->sender()->SetParameters(parameters); RTCError error = video_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION); EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1572,12 +1555,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper); ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
absl::optional<webrtc::RtpCodecCapability> vp8 = absl::optional<RtpCodecCapability> vp8 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp8"); "vp8");
ASSERT_TRUE(vp8); ASSERT_TRUE(vp8);
std::vector<webrtc::RtpCodecCapability> not_vp8_codecs = std::vector<RtpCodecCapability> not_vp8_codecs =
local_pc_wrapper->pc_factory() local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO) ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO)
.codecs; .codecs;
@ -1622,8 +1605,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->WaitForConnection(); local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection(); remote_pc_wrapper->WaitForConnection();
webrtc::RtpParameters parameters = RtpParameters parameters = video_transceiver->sender()->GetParameters();
video_transceiver->sender()->GetParameters();
parameters.encodings[0].codec = vp8; parameters.encodings[0].codec = vp8;
RTCError error = video_transceiver->sender()->SetParameters(parameters); RTCError error = video_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION); EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1635,12 +1617,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper); ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
absl::optional<webrtc::RtpCodecCapability> opus = absl::optional<RtpCodecCapability> opus =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"opus"); "opus");
ASSERT_TRUE(opus); ASSERT_TRUE(opus);
std::vector<webrtc::RtpCodecCapability> not_opus_codecs = std::vector<RtpCodecCapability> not_opus_codecs =
local_pc_wrapper->pc_factory() local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO) ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
.codecs; .codecs;
@ -1651,9 +1633,9 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
}), }),
not_opus_codecs.end()); not_opus_codecs.end());
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly; init.direction = RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
encoding_parameters.codec = opus; encoding_parameters.codec = opus;
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
@ -1667,8 +1649,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->WaitForConnection(); local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection(); remote_pc_wrapper->WaitForConnection();
webrtc::RtpParameters parameters = RtpParameters parameters = audio_transceiver->sender()->GetParameters();
audio_transceiver->sender()->GetParameters();
EXPECT_EQ(parameters.encodings[0].codec, opus); EXPECT_EQ(parameters.encodings[0].codec, opus);
ASSERT_TRUE(audio_transceiver->SetCodecPreferences(not_opus_codecs).ok()); ASSERT_TRUE(audio_transceiver->SetCodecPreferences(not_opus_codecs).ok());
@ -1684,24 +1665,24 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper); ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
std::vector<webrtc::RtpCodecCapability> send_codecs = std::vector<RtpCodecCapability> send_codecs =
local_pc_wrapper->pc_factory() local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO) ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
.codecs; .codecs;
absl::optional<webrtc::RtpCodecCapability> opus = absl::optional<RtpCodecCapability> opus =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"opus"); "opus");
ASSERT_TRUE(opus); ASSERT_TRUE(opus);
absl::optional<webrtc::RtpCodecCapability> red = absl::optional<RtpCodecCapability> red =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
"red"); "red");
ASSERT_TRUE(red); ASSERT_TRUE(red);
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly; init.direction = RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
encoding_parameters.codec = opus; encoding_parameters.codec = opus;
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
@ -1720,8 +1701,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->WaitForConnection(); local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection(); remote_pc_wrapper->WaitForConnection();
webrtc::RtpParameters parameters = RtpParameters parameters = audio_transceiver->sender()->GetParameters();
audio_transceiver->sender()->GetParameters();
EXPECT_EQ(parameters.encodings[0].codec, opus); EXPECT_EQ(parameters.encodings[0].codec, opus);
EXPECT_EQ(parameters.codecs[0].payload_type, red->preferred_payload_type); EXPECT_EQ(parameters.codecs[0].payload_type, red->preferred_payload_type);
EXPECT_EQ(parameters.codecs[0].name, red->name); EXPECT_EQ(parameters.codecs[0].name, red->name);
@ -1743,14 +1723,14 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
SetParametersRejectsScalabilityModeForSelectedCodec) { SetParametersRejectsScalabilityModeForSelectedCodec) {
rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc(); 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, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp8"); "vp8");
ASSERT_TRUE(vp8); ASSERT_TRUE(vp8);
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly; init.direction = RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
encoding_parameters.codec = vp8; encoding_parameters.codec = vp8;
encoding_parameters.scalability_mode = "L1T3"; encoding_parameters.scalability_mode = "L1T3";
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
@ -1761,8 +1741,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver = rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
transceiver_or_error.MoveValue(); transceiver_or_error.MoveValue();
webrtc::RtpParameters parameters = RtpParameters parameters = video_transceiver->sender()->GetParameters();
video_transceiver->sender()->GetParameters();
parameters.encodings[0].scalability_mode = "L3T3"; parameters.encodings[0].scalability_mode = "L3T3";
RTCError error = video_transceiver->sender()->SetParameters(parameters); RTCError error = video_transceiver->sender()->SetParameters(parameters);
EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION); EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@ -1774,12 +1753,12 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper); ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
absl::optional<webrtc::RtpCodecCapability> vp8 = absl::optional<RtpCodecCapability> vp8 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp8"); "vp8");
ASSERT_TRUE(vp8); ASSERT_TRUE(vp8);
std::vector<webrtc::RtpCodecCapability> not_vp8_codecs = std::vector<RtpCodecCapability> not_vp8_codecs =
local_pc_wrapper->pc_factory() local_pc_wrapper->pc_factory()
->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO) ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO)
.codecs; .codecs;
@ -1790,9 +1769,9 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
}), }),
not_vp8_codecs.end()); not_vp8_codecs.end());
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly; init.direction = RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
encoding_parameters.rid = "h"; encoding_parameters.rid = "h";
encoding_parameters.codec = vp8; encoding_parameters.codec = vp8;
encoding_parameters.scale_resolution_down_by = 2; encoding_parameters.scale_resolution_down_by = 2;
@ -1811,8 +1790,7 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
local_pc_wrapper->WaitForConnection(); local_pc_wrapper->WaitForConnection();
remote_pc_wrapper->WaitForConnection(); remote_pc_wrapper->WaitForConnection();
webrtc::RtpParameters parameters = RtpParameters parameters = video_transceiver->sender()->GetParameters();
video_transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 2u); ASSERT_EQ(parameters.encodings.size(), 2u);
EXPECT_EQ(parameters.encodings[0].codec, vp8); EXPECT_EQ(parameters.encodings[0].codec, vp8);
EXPECT_EQ(parameters.encodings[1].codec, vp8); EXPECT_EQ(parameters.encodings[1].codec, vp8);
@ -1833,17 +1811,17 @@ TEST_F(PeerConnectionEncodingsIntegrationTest,
rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc(); rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper); ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
absl::optional<webrtc::RtpCodecCapability> vp8 = absl::optional<RtpCodecCapability> vp8 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp8"); "vp8");
ASSERT_TRUE(vp8); ASSERT_TRUE(vp8);
absl::optional<webrtc::RtpCodecCapability> vp9 = absl::optional<RtpCodecCapability> vp9 =
local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO, local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
"vp9"); "vp9");
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
init.direction = webrtc::RtpTransceiverDirection::kSendOnly; init.direction = RtpTransceiverDirection::kSendOnly;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
encoding_parameters.rid = "h"; encoding_parameters.rid = "h";
encoding_parameters.codec = vp8; encoding_parameters.codec = vp8;
encoding_parameters.scale_resolution_down_by = 2; 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, CreatePeerConnectionOrError,
const PeerConnectionInterface::RTCConfiguration&, const PeerConnectionInterface::RTCConfiguration&,
PeerConnectionDependencies) PeerConnectionDependencies)
PROXY_CONSTMETHOD1(webrtc::RtpCapabilities, PROXY_CONSTMETHOD1(RtpCapabilities,
GetRtpSenderCapabilities, GetRtpSenderCapabilities,
cricket::MediaType) cricket::MediaType)
PROXY_CONSTMETHOD1(webrtc::RtpCapabilities, PROXY_CONSTMETHOD1(RtpCapabilities,
GetRtpReceiverCapabilities, GetRtpReceiverCapabilities,
cricket::MediaType) cricket::MediaType)
PROXY_METHOD1(rtc::scoped_refptr<MediaStreamInterface>, 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 {} PeerConnectionInterface::IceConnectionState new_state) override {}
void OnIceGatheringChange( void OnIceGatheringChange(
PeerConnectionInterface::IceGatheringState new_state) override {} PeerConnectionInterface::IceGatheringState new_state) override {}
void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override { void OnIceCandidate(const IceCandidateInterface* candidate) override {}
}
}; };
class MockNetworkManager : public rtc::NetworkManager { class MockNetworkManager : public rtc::NetworkManager {
@ -133,17 +132,15 @@ class PeerConnectionFactoryTest : public ::testing::Test {
private: private:
void SetUp() { void SetUp() {
#ifdef WEBRTC_ANDROID #ifdef WEBRTC_ANDROID
webrtc::InitializeAndroidObjects(); InitializeAndroidObjects();
#endif #endif
// Use fake audio device module since we're only testing the interface // 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 // level, and using a real one could make tests flaky e.g. when run in
// parallel. // parallel.
factory_ = webrtc::CreatePeerConnectionFactory( factory_ = CreatePeerConnectionFactory(
rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
rtc::scoped_refptr<webrtc::AudioDeviceModule>( rtc::scoped_refptr<AudioDeviceModule>(FakeAudioCaptureModule::Create()),
FakeAudioCaptureModule::Create()), CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
webrtc::CreateBuiltinAudioEncoderFactory(),
webrtc::CreateBuiltinAudioDecoderFactory(),
std::make_unique<VideoEncoderFactoryTemplate< std::make_unique<VideoEncoderFactoryTemplate<
LibvpxVp8EncoderTemplateAdapter, LibvpxVp9EncoderTemplateAdapter, LibvpxVp8EncoderTemplateAdapter, LibvpxVp9EncoderTemplateAdapter,
OpenH264EncoderTemplateAdapter, LibaomAv1EncoderTemplateAdapter>>(), 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_EQ(codec.kind, cricket::MEDIA_TYPE_AUDIO);
EXPECT_FALSE(codec.name.empty()); EXPECT_FALSE(codec.name.empty());
EXPECT_GT(codec.clock_rate, 0); EXPECT_GT(codec.clock_rate, 0);
EXPECT_GT(codec.num_channels, 0); EXPECT_GT(codec.num_channels, 0);
} }
void VerifyVideoCodecCapability(const webrtc::RtpCodecCapability& codec, void VerifyVideoCodecCapability(const RtpCodecCapability& codec,
bool sender) { bool sender) {
EXPECT_EQ(codec.kind, cricket::MEDIA_TYPE_VIDEO); EXPECT_EQ(codec.kind, cricket::MEDIA_TYPE_VIDEO);
EXPECT_FALSE(codec.name.empty()); EXPECT_FALSE(codec.name.empty());
EXPECT_GT(codec.clock_rate, 0); EXPECT_GT(codec.clock_rate, 0);
if (sender) { if (sender) {
if (codec.name == "VP8" || codec.name == "H264") { if (codec.name == "VP8" || codec.name == "H264") {
EXPECT_THAT(codec.scalability_modes, EXPECT_THAT(
UnorderedElementsAre(webrtc::ScalabilityMode::kL1T1, codec.scalability_modes,
webrtc::ScalabilityMode::kL1T2, UnorderedElementsAre(ScalabilityMode::kL1T1, ScalabilityMode::kL1T2,
webrtc::ScalabilityMode::kL1T3)) ScalabilityMode::kL1T3))
<< "Codec: " << codec.name; << "Codec: " << codec.name;
} else if (codec.name == "VP9" || codec.name == "AV1") { } else if (codec.name == "VP9" || codec.name == "AV1") {
EXPECT_THAT( EXPECT_THAT(
codec.scalability_modes, codec.scalability_modes,
UnorderedElementsAre( UnorderedElementsAre(
// clang-format off // clang-format off
webrtc::ScalabilityMode::kL1T1, ScalabilityMode::kL1T1,
webrtc::ScalabilityMode::kL1T2, ScalabilityMode::kL1T2,
webrtc::ScalabilityMode::kL1T3, ScalabilityMode::kL1T3,
webrtc::ScalabilityMode::kL2T1, ScalabilityMode::kL2T1,
webrtc::ScalabilityMode::kL2T1h, ScalabilityMode::kL2T1h,
webrtc::ScalabilityMode::kL2T1_KEY, ScalabilityMode::kL2T1_KEY,
webrtc::ScalabilityMode::kL2T2, ScalabilityMode::kL2T2,
webrtc::ScalabilityMode::kL2T2h, ScalabilityMode::kL2T2h,
webrtc::ScalabilityMode::kL2T2_KEY, ScalabilityMode::kL2T2_KEY,
webrtc::ScalabilityMode::kL2T2_KEY_SHIFT, ScalabilityMode::kL2T2_KEY_SHIFT,
webrtc::ScalabilityMode::kL2T3, ScalabilityMode::kL2T3,
webrtc::ScalabilityMode::kL2T3h, ScalabilityMode::kL2T3h,
webrtc::ScalabilityMode::kL2T3_KEY, ScalabilityMode::kL2T3_KEY,
webrtc::ScalabilityMode::kL3T1, ScalabilityMode::kL3T1,
webrtc::ScalabilityMode::kL3T1h, ScalabilityMode::kL3T1h,
webrtc::ScalabilityMode::kL3T1_KEY, ScalabilityMode::kL3T1_KEY,
webrtc::ScalabilityMode::kL3T2, ScalabilityMode::kL3T2,
webrtc::ScalabilityMode::kL3T2h, ScalabilityMode::kL3T2h,
webrtc::ScalabilityMode::kL3T2_KEY, ScalabilityMode::kL3T2_KEY,
webrtc::ScalabilityMode::kL3T3, ScalabilityMode::kL3T3,
webrtc::ScalabilityMode::kL3T3h, ScalabilityMode::kL3T3h,
webrtc::ScalabilityMode::kL3T3_KEY, ScalabilityMode::kL3T3_KEY,
webrtc::ScalabilityMode::kS2T1, ScalabilityMode::kS2T1,
webrtc::ScalabilityMode::kS2T1h, ScalabilityMode::kS2T1h,
webrtc::ScalabilityMode::kS2T2, ScalabilityMode::kS2T2,
webrtc::ScalabilityMode::kS2T2h, ScalabilityMode::kS2T2h,
webrtc::ScalabilityMode::kS2T3, ScalabilityMode::kS2T3,
webrtc::ScalabilityMode::kS2T3h, ScalabilityMode::kS2T3h,
webrtc::ScalabilityMode::kS3T1, ScalabilityMode::kS3T1,
webrtc::ScalabilityMode::kS3T1h, ScalabilityMode::kS3T1h,
webrtc::ScalabilityMode::kS3T2, ScalabilityMode::kS3T2,
webrtc::ScalabilityMode::kS3T2h, ScalabilityMode::kS3T2h,
webrtc::ScalabilityMode::kS3T3, ScalabilityMode::kS3T3,
webrtc::ScalabilityMode::kS3T3h) ScalabilityMode::kS3T3h)
// clang-format on // clang-format on
) )
<< "Codec: " << codec.name; << "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_; std::unique_ptr<rtc::SocketServer> socket_server_;
rtc::AutoSocketServerThread main_thread_; rtc::AutoSocketServerThread main_thread_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> factory_; rtc::scoped_refptr<PeerConnectionFactoryInterface> factory_;
@ -267,7 +264,7 @@ class PeerConnectionFactoryTest : public ::testing::Test {
// to reconstruct factory with our own ConnectionContext. // to reconstruct factory with our own ConnectionContext.
rtc::scoped_refptr<PeerConnectionFactoryInterface> rtc::scoped_refptr<PeerConnectionFactoryInterface>
CreatePeerConnectionFactoryWithRtxDisabled() { CreatePeerConnectionFactoryWithRtxDisabled() {
webrtc::PeerConnectionFactoryDependencies pcf_dependencies; PeerConnectionFactoryDependencies pcf_dependencies;
pcf_dependencies.signaling_thread = rtc::Thread::Current(); pcf_dependencies.signaling_thread = rtc::Thread::Current();
pcf_dependencies.worker_thread = rtc::Thread::Current(); pcf_dependencies.worker_thread = rtc::Thread::Current();
pcf_dependencies.network_thread = rtc::Thread::Current(); pcf_dependencies.network_thread = rtc::Thread::Current();
@ -287,7 +284,7 @@ CreatePeerConnectionFactoryWithRtxDisabled() {
OpenH264DecoderTemplateAdapter, Dav1dDecoderTemplateAdapter>>(), OpenH264DecoderTemplateAdapter, Dav1dDecoderTemplateAdapter>>(),
EnableMedia(pcf_dependencies); EnableMedia(pcf_dependencies);
rtc::scoped_refptr<webrtc::ConnectionContext> context = rtc::scoped_refptr<ConnectionContext> context =
ConnectionContext::Create(&pcf_dependencies); ConnectionContext::Create(&pcf_dependencies);
context->set_use_rtx(false); context->set_use_rtx(false);
return rtc::make_ref_counted<PeerConnectionFactory>(context, 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. // See https://bugs.chromium.org/p/webrtc/issues/detail?id=7806 for details.
TEST(PeerConnectionFactoryTestInternal, DISABLED_CreatePCUsingInternalModules) { TEST(PeerConnectionFactoryTestInternal, DISABLED_CreatePCUsingInternalModules) {
#ifdef WEBRTC_ANDROID #ifdef WEBRTC_ANDROID
webrtc::InitializeAndroidObjects(); InitializeAndroidObjects();
#endif #endif
rtc::scoped_refptr<PeerConnectionFactoryInterface> factory( rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
webrtc::CreatePeerConnectionFactory( CreatePeerConnectionFactory(
nullptr /* network_thread */, nullptr /* worker_thread */, nullptr /* network_thread */, nullptr /* worker_thread */,
nullptr /* signaling_thread */, nullptr /* default_adm */, nullptr /* signaling_thread */, nullptr /* default_adm */,
webrtc::CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioEncoderFactory(),
webrtc::CreateBuiltinAudioDecoderFactory(), CreateBuiltinAudioDecoderFactory(),
nullptr /* video_encoder_factory */, nullptr /* video_encoder_factory */,
nullptr /* video_decoder_factory */, nullptr /* audio_mixer */, nullptr /* video_decoder_factory */, nullptr /* audio_mixer */,
nullptr /* audio_processing */)); nullptr /* audio_processing */));
NullPeerConnectionObserver observer; NullPeerConnectionObserver observer;
webrtc::PeerConnectionInterface::RTCConfiguration config; PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan; config.sdp_semantics = SdpSemantics::kUnifiedPlan;
std::unique_ptr<FakeRTCCertificateGenerator> cert_generator( std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
new FakeRTCCertificateGenerator()); new FakeRTCCertificateGenerator());
webrtc::PeerConnectionDependencies pc_dependencies(&observer); PeerConnectionDependencies pc_dependencies(&observer);
pc_dependencies.cert_generator = std::move(cert_generator); pc_dependencies.cert_generator = std::move(cert_generator);
auto result = auto result =
factory->CreatePeerConnectionOrError(config, std::move(pc_dependencies)); factory->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
@ -330,7 +327,7 @@ TEST(PeerConnectionFactoryTestInternal, DISABLED_CreatePCUsingInternalModules) {
} }
TEST_F(PeerConnectionFactoryTest, CheckRtpSenderAudioCapabilities) { TEST_F(PeerConnectionFactoryTest, CheckRtpSenderAudioCapabilities) {
webrtc::RtpCapabilities audio_capabilities = RtpCapabilities audio_capabilities =
factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO); factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO);
EXPECT_FALSE(audio_capabilities.codecs.empty()); EXPECT_FALSE(audio_capabilities.codecs.empty());
for (const auto& codec : audio_capabilities.codecs) { for (const auto& codec : audio_capabilities.codecs) {
@ -343,7 +340,7 @@ TEST_F(PeerConnectionFactoryTest, CheckRtpSenderAudioCapabilities) {
} }
TEST_F(PeerConnectionFactoryTest, CheckRtpSenderVideoCapabilities) { TEST_F(PeerConnectionFactoryTest, CheckRtpSenderVideoCapabilities) {
webrtc::RtpCapabilities video_capabilities = RtpCapabilities video_capabilities =
factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO); factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO);
EXPECT_FALSE(video_capabilities.codecs.empty()); EXPECT_FALSE(video_capabilities.codecs.empty());
for (const auto& codec : video_capabilities.codecs) { for (const auto& codec : video_capabilities.codecs) {
@ -356,7 +353,7 @@ TEST_F(PeerConnectionFactoryTest, CheckRtpSenderVideoCapabilities) {
} }
TEST_F(PeerConnectionFactoryTest, CheckRtpSenderRtxEnabledCapabilities) { TEST_F(PeerConnectionFactoryTest, CheckRtpSenderRtxEnabledCapabilities) {
webrtc::RtpCapabilities video_capabilities = RtpCapabilities video_capabilities =
factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO); factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO);
const auto it = std::find_if( const auto it = std::find_if(
video_capabilities.codecs.begin(), video_capabilities.codecs.end(), video_capabilities.codecs.begin(), video_capabilities.codecs.end(),
@ -366,7 +363,7 @@ TEST_F(PeerConnectionFactoryTest, CheckRtpSenderRtxEnabledCapabilities) {
TEST(PeerConnectionFactoryTestInternal, CheckRtpSenderRtxDisabledCapabilities) { TEST(PeerConnectionFactoryTestInternal, CheckRtpSenderRtxDisabledCapabilities) {
auto factory = CreatePeerConnectionFactoryWithRtxDisabled(); auto factory = CreatePeerConnectionFactoryWithRtxDisabled();
webrtc::RtpCapabilities video_capabilities = RtpCapabilities video_capabilities =
factory->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO); factory->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO);
const auto it = std::find_if( const auto it = std::find_if(
video_capabilities.codecs.begin(), video_capabilities.codecs.end(), video_capabilities.codecs.begin(), video_capabilities.codecs.end(),
@ -375,14 +372,14 @@ TEST(PeerConnectionFactoryTestInternal, CheckRtpSenderRtxDisabledCapabilities) {
} }
TEST_F(PeerConnectionFactoryTest, CheckRtpSenderDataCapabilities) { TEST_F(PeerConnectionFactoryTest, CheckRtpSenderDataCapabilities) {
webrtc::RtpCapabilities data_capabilities = RtpCapabilities data_capabilities =
factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_DATA); factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_DATA);
EXPECT_TRUE(data_capabilities.codecs.empty()); EXPECT_TRUE(data_capabilities.codecs.empty());
EXPECT_TRUE(data_capabilities.header_extensions.empty()); EXPECT_TRUE(data_capabilities.header_extensions.empty());
} }
TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverAudioCapabilities) { TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverAudioCapabilities) {
webrtc::RtpCapabilities audio_capabilities = RtpCapabilities audio_capabilities =
factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_AUDIO); factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_AUDIO);
EXPECT_FALSE(audio_capabilities.codecs.empty()); EXPECT_FALSE(audio_capabilities.codecs.empty());
for (const auto& codec : audio_capabilities.codecs) { for (const auto& codec : audio_capabilities.codecs) {
@ -395,7 +392,7 @@ TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverAudioCapabilities) {
} }
TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverVideoCapabilities) { TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverVideoCapabilities) {
webrtc::RtpCapabilities video_capabilities = RtpCapabilities video_capabilities =
factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_VIDEO); factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_VIDEO);
EXPECT_FALSE(video_capabilities.codecs.empty()); EXPECT_FALSE(video_capabilities.codecs.empty());
for (const auto& codec : video_capabilities.codecs) { for (const auto& codec : video_capabilities.codecs) {
@ -408,7 +405,7 @@ TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverVideoCapabilities) {
} }
TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverRtxEnabledCapabilities) { TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverRtxEnabledCapabilities) {
webrtc::RtpCapabilities video_capabilities = RtpCapabilities video_capabilities =
factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_VIDEO); factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_VIDEO);
const auto it = std::find_if( const auto it = std::find_if(
video_capabilities.codecs.begin(), video_capabilities.codecs.end(), video_capabilities.codecs.begin(), video_capabilities.codecs.end(),
@ -419,7 +416,7 @@ TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverRtxEnabledCapabilities) {
TEST(PeerConnectionFactoryTestInternal, TEST(PeerConnectionFactoryTestInternal,
CheckRtpReceiverRtxDisabledCapabilities) { CheckRtpReceiverRtxDisabledCapabilities) {
auto factory = CreatePeerConnectionFactoryWithRtxDisabled(); auto factory = CreatePeerConnectionFactoryWithRtxDisabled();
webrtc::RtpCapabilities video_capabilities = RtpCapabilities video_capabilities =
factory->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_VIDEO); factory->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_VIDEO);
const auto it = std::find_if( const auto it = std::find_if(
video_capabilities.codecs.begin(), video_capabilities.codecs.end(), video_capabilities.codecs.begin(), video_capabilities.codecs.end(),
@ -428,7 +425,7 @@ TEST(PeerConnectionFactoryTestInternal,
} }
TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverDataCapabilities) { TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverDataCapabilities) {
webrtc::RtpCapabilities data_capabilities = RtpCapabilities data_capabilities =
factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_DATA); factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_DATA);
EXPECT_TRUE(data_capabilities.codecs.empty()); EXPECT_TRUE(data_capabilities.codecs.empty());
EXPECT_TRUE(data_capabilities.header_extensions.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. // configuration. Also verifies the URL's parsed correctly as expected.
TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServers) { TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServers) {
PeerConnectionInterface::RTCConfiguration config; PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan; config.sdp_semantics = SdpSemantics::kUnifiedPlan;
webrtc::PeerConnectionInterface::IceServer ice_server; PeerConnectionInterface::IceServer ice_server;
ice_server.uri = kStunIceServer; ice_server.uri = kStunIceServer;
config.servers.push_back(ice_server); config.servers.push_back(ice_server);
ice_server.uri = kTurnIceServer; ice_server.uri = kTurnIceServer;
@ -450,7 +447,7 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServers) {
ice_server.username = kTurnUsername; ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword; ice_server.password = kTurnPassword;
config.servers.push_back(ice_server); config.servers.push_back(ice_server);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_); PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator = pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>(); std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_); 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. // configuration. Also verifies the list of URL's parsed correctly as expected.
TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServersUrls) { TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServersUrls) {
PeerConnectionInterface::RTCConfiguration config; PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan; config.sdp_semantics = SdpSemantics::kUnifiedPlan;
webrtc::PeerConnectionInterface::IceServer ice_server; PeerConnectionInterface::IceServer ice_server;
ice_server.urls.push_back(kStunIceServer); ice_server.urls.push_back(kStunIceServer);
ice_server.urls.push_back(kTurnIceServer); ice_server.urls.push_back(kTurnIceServer);
ice_server.urls.push_back(kTurnIceServerWithTransport); ice_server.urls.push_back(kTurnIceServerWithTransport);
ice_server.username = kTurnUsername; ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword; ice_server.password = kTurnPassword;
config.servers.push_back(ice_server); config.servers.push_back(ice_server);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_); PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator = pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>(); std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_); pc_dependencies.allocator = std::move(port_allocator_);
@ -506,15 +503,15 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServersUrls) {
TEST_F(PeerConnectionFactoryTest, CreatePCUsingNoUsernameInUri) { TEST_F(PeerConnectionFactoryTest, CreatePCUsingNoUsernameInUri) {
PeerConnectionInterface::RTCConfiguration config; PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan; config.sdp_semantics = SdpSemantics::kUnifiedPlan;
webrtc::PeerConnectionInterface::IceServer ice_server; PeerConnectionInterface::IceServer ice_server;
ice_server.uri = kStunIceServer; ice_server.uri = kStunIceServer;
config.servers.push_back(ice_server); config.servers.push_back(ice_server);
ice_server.uri = kTurnIceServerWithNoUsernameInUri; ice_server.uri = kTurnIceServerWithNoUsernameInUri;
ice_server.username = kTurnUsername; ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword; ice_server.password = kTurnPassword;
config.servers.push_back(ice_server); config.servers.push_back(ice_server);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_); PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator = pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>(); std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_); pc_dependencies.allocator = std::move(port_allocator_);
@ -532,13 +529,13 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingNoUsernameInUri) {
// has transport parameter in it. // has transport parameter in it.
TEST_F(PeerConnectionFactoryTest, CreatePCUsingTurnUrlWithTransportParam) { TEST_F(PeerConnectionFactoryTest, CreatePCUsingTurnUrlWithTransportParam) {
PeerConnectionInterface::RTCConfiguration config; PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan; config.sdp_semantics = SdpSemantics::kUnifiedPlan;
webrtc::PeerConnectionInterface::IceServer ice_server; PeerConnectionInterface::IceServer ice_server;
ice_server.uri = kTurnIceServerWithTransport; ice_server.uri = kTurnIceServerWithTransport;
ice_server.username = kTurnUsername; ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword; ice_server.password = kTurnPassword;
config.servers.push_back(ice_server); config.servers.push_back(ice_server);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_); PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator = pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>(); std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_); pc_dependencies.allocator = std::move(port_allocator_);
@ -554,8 +551,8 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingTurnUrlWithTransportParam) {
TEST_F(PeerConnectionFactoryTest, CreatePCUsingSecureTurnUrl) { TEST_F(PeerConnectionFactoryTest, CreatePCUsingSecureTurnUrl) {
PeerConnectionInterface::RTCConfiguration config; PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan; config.sdp_semantics = SdpSemantics::kUnifiedPlan;
webrtc::PeerConnectionInterface::IceServer ice_server; PeerConnectionInterface::IceServer ice_server;
ice_server.uri = kSecureTurnIceServer; ice_server.uri = kSecureTurnIceServer;
ice_server.username = kTurnUsername; ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword; ice_server.password = kTurnPassword;
@ -568,7 +565,7 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingSecureTurnUrl) {
ice_server.username = kTurnUsername; ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword; ice_server.password = kTurnPassword;
config.servers.push_back(ice_server); config.servers.push_back(ice_server);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_); PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator = pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>(); std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_); pc_dependencies.allocator = std::move(port_allocator_);
@ -593,8 +590,8 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingSecureTurnUrl) {
TEST_F(PeerConnectionFactoryTest, CreatePCUsingIPLiteralAddress) { TEST_F(PeerConnectionFactoryTest, CreatePCUsingIPLiteralAddress) {
PeerConnectionInterface::RTCConfiguration config; PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan; config.sdp_semantics = SdpSemantics::kUnifiedPlan;
webrtc::PeerConnectionInterface::IceServer ice_server; PeerConnectionInterface::IceServer ice_server;
ice_server.uri = kStunIceServerWithIPv4Address; ice_server.uri = kStunIceServerWithIPv4Address;
config.servers.push_back(ice_server); config.servers.push_back(ice_server);
ice_server.uri = kStunIceServerWithIPv4AddressWithoutPort; ice_server.uri = kStunIceServerWithIPv4AddressWithoutPort;
@ -607,7 +604,7 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIPLiteralAddress) {
ice_server.username = kTurnUsername; ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword; ice_server.password = kTurnPassword;
config.servers.push_back(ice_server); config.servers.push_back(ice_server);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_); PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator = pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>(); std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_); 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 // This test verifies the captured stream is rendered locally using a
// local video track. // local video track.
TEST_F(PeerConnectionFactoryTest, LocalRendering) { TEST_F(PeerConnectionFactoryTest, LocalRendering) {
rtc::scoped_refptr<webrtc::FakeVideoTrackSource> source = rtc::scoped_refptr<FakeVideoTrackSource> source =
webrtc::FakeVideoTrackSource::Create(/*is_screencast=*/false); FakeVideoTrackSource::Create(/*is_screencast=*/false);
cricket::FakeFrameSource frame_source(1280, 720, cricket::FakeFrameSource frame_source(1280, 720,
rtc::kNumMicrosecsPerSec / 30); rtc::kNumMicrosecsPerSec / 30);
@ -664,7 +661,7 @@ TEST_F(PeerConnectionFactoryTest, LocalRendering) {
} }
TEST(PeerConnectionFactoryDependenciesTest, UsesNetworkManager) { 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>>(); auto mock_network_manager = std::make_unique<NiceMock<MockNetworkManager>>();
rtc::Event called; rtc::Event called;
@ -672,24 +669,24 @@ TEST(PeerConnectionFactoryDependenciesTest, UsesNetworkManager) {
.Times(AtLeast(1)) .Times(AtLeast(1))
.WillRepeatedly(InvokeWithoutArgs([&] { called.Set(); })); .WillRepeatedly(InvokeWithoutArgs([&] { called.Set(); }));
webrtc::PeerConnectionFactoryDependencies pcf_dependencies; PeerConnectionFactoryDependencies pcf_dependencies;
pcf_dependencies.network_manager = std::move(mock_network_manager); 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)); CreateModularPeerConnectionFactory(std::move(pcf_dependencies));
PeerConnectionInterface::RTCConfiguration config; PeerConnectionInterface::RTCConfiguration config;
config.ice_candidate_pool_size = 2; config.ice_candidate_pool_size = 2;
NullPeerConnectionObserver observer; NullPeerConnectionObserver observer;
auto pc = pcf->CreatePeerConnectionOrError( auto pc = pcf->CreatePeerConnectionOrError(
config, webrtc::PeerConnectionDependencies(&observer)); config, PeerConnectionDependencies(&observer));
ASSERT_TRUE(pc.ok()); ASSERT_TRUE(pc.ok());
called.Wait(kWaitTimeout); called.Wait(kWaitTimeout);
} }
TEST(PeerConnectionFactoryDependenciesTest, UsesPacketSocketFactory) { TEST(PeerConnectionFactoryDependenciesTest, UsesPacketSocketFactory) {
constexpr webrtc::TimeDelta kWaitTimeout = webrtc::TimeDelta::Seconds(10); constexpr TimeDelta kWaitTimeout = TimeDelta::Seconds(10);
auto mock_socket_factory = auto mock_socket_factory =
std::make_unique<NiceMock<rtc::MockPacketSocketFactory>>(); std::make_unique<NiceMock<rtc::MockPacketSocketFactory>>();
@ -701,10 +698,10 @@ TEST(PeerConnectionFactoryDependenciesTest, UsesPacketSocketFactory) {
})) }))
.WillRepeatedly(Return(nullptr)); .WillRepeatedly(Return(nullptr));
webrtc::PeerConnectionFactoryDependencies pcf_dependencies; PeerConnectionFactoryDependencies pcf_dependencies;
pcf_dependencies.packet_socket_factory = std::move(mock_socket_factory); 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)); CreateModularPeerConnectionFactory(std::move(pcf_dependencies));
// By default, localhost addresses are ignored, which makes tests fail if test // 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; config.ice_candidate_pool_size = 2;
NullPeerConnectionObserver observer; NullPeerConnectionObserver observer;
auto pc = pcf->CreatePeerConnectionOrError( auto pc = pcf->CreatePeerConnectionOrError(
config, webrtc::PeerConnectionDependencies(&observer)); config, PeerConnectionDependencies(&observer));
ASSERT_TRUE(pc.ok()); ASSERT_TRUE(pc.ok());
called.Wait(kWaitTimeout); 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 #ifdef WEBRTC_ANDROID
InitializeAndroidObjects(); InitializeAndroidObjects();
#endif #endif
webrtc::PeerConnectionInterface::IceServer ice_server; PeerConnectionInterface::IceServer ice_server;
ice_server.uri = "stun:stun.l.google.com:19302"; ice_server.uri = "stun:stun.l.google.com:19302";
config_.servers.push_back(ice_server); config_.servers.push_back(ice_server);
config_.sdp_semantics = SdpSemantics::kUnifiedPlan; config_.sdp_semantics = SdpSemantics::kUnifiedPlan;
@ -108,7 +108,7 @@ class PeerConnectionFieldTrialTest : public ::testing::Test {
std::unique_ptr<rtc::SocketServer> socket_server_; std::unique_ptr<rtc::SocketServer> socket_server_;
rtc::AutoSocketServerThread main_thread_; rtc::AutoSocketServerThread main_thread_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_ = nullptr; rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_ = nullptr;
webrtc::PeerConnectionInterface::RTCConfiguration config_; PeerConnectionInterface::RTCConfiguration config_;
}; };
// Tests for the dependency descriptor field trial. The dependency descriptor // Tests for the dependency descriptor field trial. The dependency descriptor
@ -133,7 +133,7 @@ TEST_F(PeerConnectionFieldTrialTest, EnableDependencyDescriptorAdvertised) {
media_description1->rtp_header_extensions(); media_description1->rtp_header_extensions();
bool found = absl::c_find_if(rtp_header_extensions1, bool found = absl::c_find_if(rtp_header_extensions1,
[](const webrtc::RtpExtension& rtp_extension) { [](const RtpExtension& rtp_extension) {
return rtp_extension.uri == return rtp_extension.uri ==
RtpExtension::kDependencyDescriptorUri; RtpExtension::kDependencyDescriptorUri;
}) != rtp_header_extensions1.end(); }) != rtp_header_extensions1.end();
@ -163,14 +163,14 @@ TEST_F(PeerConnectionFieldTrialTest, InjectDependencyDescriptor) {
media_description1->rtp_header_extensions(); media_description1->rtp_header_extensions();
bool found1 = absl::c_find_if(rtp_header_extensions1, bool found1 = absl::c_find_if(rtp_header_extensions1,
[](const webrtc::RtpExtension& rtp_extension) { [](const RtpExtension& rtp_extension) {
return rtp_extension.uri == return rtp_extension.uri ==
RtpExtension::kDependencyDescriptorUri; RtpExtension::kDependencyDescriptorUri;
}) != rtp_header_extensions1.end(); }) != rtp_header_extensions1.end();
EXPECT_FALSE(found1); EXPECT_FALSE(found1);
std::set<int> existing_ids; 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); existing_ids.insert(rtp_extension.id);
} }
@ -207,7 +207,7 @@ TEST_F(PeerConnectionFieldTrialTest, InjectDependencyDescriptor) {
media_description2->rtp_header_extensions(); media_description2->rtp_header_extensions();
bool found2 = absl::c_find_if(rtp_header_extensions2, bool found2 = absl::c_find_if(rtp_header_extensions2,
[](const webrtc::RtpExtension& rtp_extension) { [](const RtpExtension& rtp_extension) {
return rtp_extension.uri == return rtp_extension.uri ==
RtpExtension::kDependencyDescriptorUri; RtpExtension::kDependencyDescriptorUri;
}) != rtp_header_extensions2.end(); }) != 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)); pc_factory, result.MoveValue(), std::move(observer));
} }
webrtc::test::ScopedKeyValueConfig field_trials_; test::ScopedKeyValueConfig field_trials_;
std::unique_ptr<rtc::SocketServer> socket_server_; std::unique_ptr<rtc::SocketServer> socket_server_;
rtc::AutoSocketServerThread main_thread_; rtc::AutoSocketServerThread main_thread_;
std::vector<RtpHeaderExtensionCapability> extensions_; std::vector<RtpHeaderExtensionCapability> extensions_;

120
pc/peer_connection_histogram_unittest.cc
View File

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

6
pc/peer_connection_ice_unittest.cc
View File

@ -342,7 +342,7 @@ class PeerConnectionIceTest
public ::testing::WithParamInterface<SdpSemantics> { public ::testing::WithParamInterface<SdpSemantics> {
protected: protected:
PeerConnectionIceTest() : PeerConnectionIceBaseTest(GetParam()) { 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_FALSE(caller->pc()->AddIceCandidate(jsep_candidate.get()));
EXPECT_METRIC_THAT( EXPECT_METRIC_THAT(
webrtc::metrics::Samples("WebRTC.PeerConnection.AddIceCandidate"), metrics::Samples("WebRTC.PeerConnection.AddIceCandidate"),
ElementsAre(Pair(kAddIceCandidateFailNoRemoteDescription, 2))); ElementsAre(Pair(kAddIceCandidateFailNoRemoteDescription, 2)));
} }
@ -1457,7 +1457,7 @@ class PeerConnectionIceConfigTest : public ::testing::Test {
pc_ = result.MoveValue(); pc_ = result.MoveValue();
} }
webrtc::test::ScopedKeyValueConfig field_trials_; test::ScopedKeyValueConfig field_trials_;
std::unique_ptr<rtc::SocketServer> socket_server_; std::unique_ptr<rtc::SocketServer> socket_server_;
rtc::AutoSocketServerThread main_thread_; rtc::AutoSocketServerThread main_thread_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_ = nullptr; 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 // Some things use a time of "0" as a special value, so we need to start out
// the fake clock at a nonzero time. // the fake clock at a nonzero time.
// TODO(deadbeef): Fix this. // TODO(deadbeef): Fix this.
AdvanceTime(webrtc::TimeDelta::Seconds(1)); AdvanceTime(TimeDelta::Seconds(1));
} }
// Explicit handle. // Explicit handle.
@ -324,7 +324,7 @@ TEST_P(PeerConnectionIntegrationTest,
ConnectFakeSignaling(); ConnectFakeSignaling();
// Add video tracks with 16:9 aspect ratio, size 1280 x 720. // Add video tracks with 16:9 aspect ratio, size 1280 x 720.
webrtc::FakePeriodicVideoSource::Config config; FakePeriodicVideoSource::Config config;
config.width = 1280; config.width = 1280;
config.height = 720; config.height = 720;
config.timestamp_offset_ms = rtc::TimeMillis(); config.timestamp_offset_ms = rtc::TimeMillis();
@ -366,7 +366,7 @@ TEST_P(PeerConnectionIntegrationTest, EndToEndCallWithSendOnlyVideo) {
CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/true)); CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/true));
ConnectFakeSignaling(); ConnectFakeSignaling();
// Add one-directional video, from caller to callee. // Add one-directional video, from caller to callee.
rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track = rtc::scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack(); caller()->CreateLocalVideoTrack();
caller()->AddTrack(caller_track); caller()->AddTrack(caller_track);
PeerConnectionInterface::RTCOfferAnswerOptions options; PeerConnectionInterface::RTCOfferAnswerOptions options;
@ -391,7 +391,7 @@ TEST_P(PeerConnectionIntegrationTest, EndToEndCallWithReceiveOnlyVideo) {
CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/false)); CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/false));
ConnectFakeSignaling(); ConnectFakeSignaling();
// Add one-directional video, from callee to caller. // Add one-directional video, from callee to caller.
rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track = rtc::scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack(); callee()->CreateLocalVideoTrack();
callee()->AddTrack(callee_track); callee()->AddTrack(callee_track);
PeerConnectionInterface::RTCOfferAnswerOptions options; PeerConnectionInterface::RTCOfferAnswerOptions options;
@ -414,14 +414,14 @@ TEST_P(PeerConnectionIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
// Add one-directional video, from caller to callee. // Add one-directional video, from caller to callee.
rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track = rtc::scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack(); caller()->CreateLocalVideoTrack();
caller()->AddTrack(caller_track); caller()->AddTrack(caller_track);
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
// Add receive video. // Add receive video.
rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track = rtc::scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack(); callee()->CreateLocalVideoTrack();
callee()->AddTrack(callee_track); callee()->AddTrack(callee_track);
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
@ -438,14 +438,14 @@ TEST_P(PeerConnectionIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
// Add one-directional video, from callee to caller. // Add one-directional video, from callee to caller.
rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track = rtc::scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack(); callee()->CreateLocalVideoTrack();
callee()->AddTrack(callee_track); callee()->AddTrack(callee_track);
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
// Add send video. // Add send video.
rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track = rtc::scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack(); caller()->CreateLocalVideoTrack();
caller()->AddTrack(caller_track); caller()->AddTrack(caller_track);
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
@ -462,15 +462,15 @@ TEST_P(PeerConnectionIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
// Add send video, from caller to callee. // Add send video, from caller to callee.
rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track = rtc::scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack(); caller()->CreateLocalVideoTrack();
rtc::scoped_refptr<webrtc::RtpSenderInterface> caller_sender = rtc::scoped_refptr<RtpSenderInterface> caller_sender =
caller()->AddTrack(caller_track); caller()->AddTrack(caller_track);
// Add receive video, from callee to caller. // Add receive video, from callee to caller.
rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track = rtc::scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack(); callee()->CreateLocalVideoTrack();
rtc::scoped_refptr<webrtc::RtpSenderInterface> callee_sender = rtc::scoped_refptr<RtpSenderInterface> callee_sender =
callee()->AddTrack(callee_track); callee()->AddTrack(callee_track);
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
@ -494,15 +494,15 @@ TEST_P(PeerConnectionIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
// Add send video, from caller to callee. // Add send video, from caller to callee.
rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track = rtc::scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack(); caller()->CreateLocalVideoTrack();
rtc::scoped_refptr<webrtc::RtpSenderInterface> caller_sender = rtc::scoped_refptr<RtpSenderInterface> caller_sender =
caller()->AddTrack(caller_track); caller()->AddTrack(caller_track);
// Add receive video, from callee to caller. // Add receive video, from callee to caller.
rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track = rtc::scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack(); callee()->CreateLocalVideoTrack();
rtc::scoped_refptr<webrtc::RtpSenderInterface> callee_sender = rtc::scoped_refptr<RtpSenderInterface> callee_sender =
callee()->AddTrack(callee_track); callee()->AddTrack(callee_track);
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
@ -654,9 +654,9 @@ TEST_P(PeerConnectionIntegrationTest, RotatedVideoWithCVOExtension) {
ConnectFakeSignaling(); ConnectFakeSignaling();
// Add rotated video tracks. // Add rotated video tracks.
caller()->AddTrack( caller()->AddTrack(
caller()->CreateLocalVideoTrackWithRotation(webrtc::kVideoRotation_90)); caller()->CreateLocalVideoTrackWithRotation(kVideoRotation_90));
callee()->AddTrack( callee()->AddTrack(
callee()->CreateLocalVideoTrackWithRotation(webrtc::kVideoRotation_270)); callee()->CreateLocalVideoTrackWithRotation(kVideoRotation_270));
// Wait for video frames to be received by both sides. // Wait for video frames to be received by both sides.
caller()->CreateAndSetAndSignalOffer(); 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()->local_rendered_aspect_ratio());
EXPECT_EQ(4.0 / 3, callee()->rendered_aspect_ratio()); EXPECT_EQ(4.0 / 3, callee()->rendered_aspect_ratio());
// Ensure that the CVO bits were surfaced to the renderer. // Ensure that the CVO bits were surfaced to the renderer.
EXPECT_EQ(webrtc::kVideoRotation_270, caller()->rendered_rotation()); EXPECT_EQ(kVideoRotation_270, caller()->rendered_rotation());
EXPECT_EQ(webrtc::kVideoRotation_90, callee()->rendered_rotation()); EXPECT_EQ(kVideoRotation_90, callee()->rendered_rotation());
} }
// Test that when the CVO extension isn't supported, video is rotated the // Test that when the CVO extension isn't supported, video is rotated the
@ -684,9 +684,9 @@ TEST_P(PeerConnectionIntegrationTest, RotatedVideoWithoutCVOExtension) {
ConnectFakeSignaling(); ConnectFakeSignaling();
// Add rotated video tracks. // Add rotated video tracks.
caller()->AddTrack( caller()->AddTrack(
caller()->CreateLocalVideoTrackWithRotation(webrtc::kVideoRotation_90)); caller()->CreateLocalVideoTrackWithRotation(kVideoRotation_90));
callee()->AddTrack( callee()->AddTrack(
callee()->CreateLocalVideoTrackWithRotation(webrtc::kVideoRotation_270)); callee()->CreateLocalVideoTrackWithRotation(kVideoRotation_270));
// Remove the CVO extension from the offered SDP. // Remove the CVO extension from the offered SDP.
callee()->SetReceivedSdpMunger([](cricket::SessionDescription* desc) { 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()->local_rendered_aspect_ratio());
EXPECT_EQ(3.0 / 4, callee()->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 that each endpoint is unaware of the rotation of the other endpoint.
EXPECT_EQ(webrtc::kVideoRotation_0, caller()->rendered_rotation()); EXPECT_EQ(kVideoRotation_0, caller()->rendered_rotation());
EXPECT_EQ(webrtc::kVideoRotation_0, callee()->rendered_rotation()); EXPECT_EQ(kVideoRotation_0, callee()->rendered_rotation());
} }
// Test that if the answerer rejects the audio m= section, no audio is sent or // Test that if the answerer rejects the audio m= section, no audio is sent or
@ -899,9 +899,9 @@ TEST_F(PeerConnectionIntegrationTestPlanB, EnableAudioAfterRejecting) {
ConnectFakeSignaling(); ConnectFakeSignaling();
// Add audio track, do normal offer/answer. // Add audio track, do normal offer/answer.
rtc::scoped_refptr<webrtc::AudioTrackInterface> track = rtc::scoped_refptr<AudioTrackInterface> track =
caller()->CreateLocalAudioTrack(); caller()->CreateLocalAudioTrack();
rtc::scoped_refptr<webrtc::RtpSenderInterface> sender = rtc::scoped_refptr<RtpSenderInterface> sender =
caller()->pc()->AddTrack(track, {"stream"}).MoveValue(); caller()->pc()->AddTrack(track, {"stream"}).MoveValue();
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
@ -974,7 +974,7 @@ TEST_F(PeerConnectionIntegrationTestUnifiedPlan,
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
// Add one-directional video, from caller to callee. // Add one-directional video, from caller to callee.
rtc::scoped_refptr<webrtc::VideoTrackInterface> track = rtc::scoped_refptr<VideoTrackInterface> track =
caller()->CreateLocalVideoTrack(); caller()->CreateLocalVideoTrack();
RtpTransceiverInit video_transceiver_init; RtpTransceiverInit video_transceiver_init;
@ -988,7 +988,7 @@ TEST_F(PeerConnectionIntegrationTestUnifiedPlan,
// Add receive direction. // Add receive direction.
video_sender->SetDirectionWithError(RtpTransceiverDirection::kSendRecv); video_sender->SetDirectionWithError(RtpTransceiverDirection::kSendRecv);
rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track = rtc::scoped_refptr<VideoTrackInterface> callee_track =
callee()->CreateLocalVideoTrack(); callee()->CreateLocalVideoTrack();
callee()->AddTrack(callee_track); callee()->AddTrack(callee_track);
@ -1348,11 +1348,11 @@ TEST_P(PeerConnectionIntegrationTest, NewGetStatsManyAudioAndManyVideoStreams) {
audio_sender_1->track()->id(), video_sender_1->track()->id(), audio_sender_1->track()->id(), video_sender_1->track()->id(),
audio_sender_2->track()->id(), video_sender_2->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(); caller()->NewGetStats();
ASSERT_TRUE(caller_report); ASSERT_TRUE(caller_report);
auto outbound_stream_stats = auto outbound_stream_stats =
caller_report->GetStatsOfType<webrtc::RTCOutboundRtpStreamStats>(); caller_report->GetStatsOfType<RTCOutboundRtpStreamStats>();
ASSERT_EQ(outbound_stream_stats.size(), 4u); ASSERT_EQ(outbound_stream_stats.size(), 4u);
std::vector<std::string> outbound_track_ids; std::vector<std::string> outbound_track_ids;
for (const auto& stat : outbound_stream_stats) { for (const auto& stat : outbound_stream_stats) {
@ -1373,11 +1373,11 @@ TEST_P(PeerConnectionIntegrationTest, NewGetStatsManyAudioAndManyVideoStreams) {
} }
EXPECT_THAT(outbound_track_ids, UnorderedElementsAreArray(track_ids)); 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(); callee()->NewGetStats();
ASSERT_TRUE(callee_report); ASSERT_TRUE(callee_report);
auto inbound_stream_stats = auto inbound_stream_stats =
callee_report->GetStatsOfType<webrtc::RTCInboundRtpStreamStats>(); callee_report->GetStatsOfType<RTCInboundRtpStreamStats>();
ASSERT_EQ(4u, inbound_stream_stats.size()); ASSERT_EQ(4u, inbound_stream_stats.size());
std::vector<std::string> inbound_track_ids; std::vector<std::string> inbound_track_ids;
for (const auto& stat : inbound_stream_stats) { 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 // We received a frame, so we should have nonzero "bytes received" stats for
// the unsignaled stream, if stats are working for it. // the unsignaled stream, if stats are working for it.
rtc::scoped_refptr<const webrtc::RTCStatsReport> report = rtc::scoped_refptr<const RTCStatsReport> report = callee()->NewGetStats();
callee()->NewGetStats();
ASSERT_NE(nullptr, report); ASSERT_NE(nullptr, report);
auto inbound_stream_stats = auto inbound_stream_stats =
report->GetStatsOfType<webrtc::RTCInboundRtpStreamStats>(); report->GetStatsOfType<RTCInboundRtpStreamStats>();
ASSERT_EQ(1U, inbound_stream_stats.size()); ASSERT_EQ(1U, inbound_stream_stats.size());
ASSERT_TRUE(inbound_stream_stats[0]->bytes_received.is_defined()); ASSERT_TRUE(inbound_stream_stats[0]->bytes_received.is_defined());
ASSERT_GT(*inbound_stream_stats[0]->bytes_received, 0U); ASSERT_GT(*inbound_stream_stats[0]->bytes_received, 0U);
@ -1459,12 +1458,10 @@ TEST_P(PeerConnectionIntegrationTest,
media_expectations.CalleeExpectsSomeVideo(1); media_expectations.CalleeExpectsSomeVideo(1);
ASSERT_TRUE(ExpectNewFrames(media_expectations)); ASSERT_TRUE(ExpectNewFrames(media_expectations));
rtc::scoped_refptr<const webrtc::RTCStatsReport> report = rtc::scoped_refptr<const RTCStatsReport> report = callee()->NewGetStats();
callee()->NewGetStats();
ASSERT_NE(nullptr, report); ASSERT_NE(nullptr, report);
auto inbound_rtps = auto inbound_rtps = report->GetStatsOfType<RTCInboundRtpStreamStats>();
report->GetStatsOfType<webrtc::RTCInboundRtpStreamStats>();
auto index = FindFirstMediaStatsIndexByKind("audio", inbound_rtps); auto index = FindFirstMediaStatsIndexByKind("audio", inbound_rtps);
ASSERT_GE(index, 0); ASSERT_GE(index, 0);
EXPECT_TRUE(inbound_rtps[index]->audio_level.is_defined()); EXPECT_TRUE(inbound_rtps[index]->audio_level.is_defined());
@ -1655,18 +1652,18 @@ TEST_P(PeerConnectionIntegrationTest, IceStatesReachCompletion) {
callee()->AddAudioVideoTracks(); callee()->AddAudioVideoTracks();
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceGatheringComplete, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringComplete,
caller()->ice_gathering_state(), kMaxWaitForFramesMs); caller()->ice_gathering_state(), kMaxWaitForFramesMs);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceGatheringComplete, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringComplete,
callee()->ice_gathering_state(), kMaxWaitForFramesMs); callee()->ice_gathering_state(), kMaxWaitForFramesMs);
// After the best candidate pair is selected and all candidates are signaled, // After the best candidate pair is selected and all candidates are signaled,
// the ICE connection state should reach "complete". // the ICE connection state should reach "complete".
// TODO(deadbeef): Currently, the ICE "controlled" agent (the // TODO(deadbeef): Currently, the ICE "controlled" agent (the
// answerer/"callee" by default) only reaches "connected". When this is // answerer/"callee" by default) only reaches "connected". When this is
// fixed, this test should be updated. // fixed, this test should be updated.
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
caller()->ice_connection_state(), kDefaultTimeout); caller()->ice_connection_state(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kDefaultTimeout); callee()->ice_connection_state(), kDefaultTimeout);
} }
@ -1679,9 +1676,9 @@ constexpr int kOnlyLocalPorts = cricket::PORTALLOCATOR_DISABLE_STUN |
TEST_P(PeerConnectionIntegrationTest, TEST_P(PeerConnectionIntegrationTest,
IceStatesReachCompletionWithRemoteHostname) { IceStatesReachCompletionWithRemoteHostname) {
auto caller_resolver_factory = auto caller_resolver_factory =
std::make_unique<NiceMock<webrtc::MockAsyncDnsResolverFactory>>(); std::make_unique<NiceMock<MockAsyncDnsResolverFactory>>();
auto callee_resolver_factory = auto callee_resolver_factory =
std::make_unique<NiceMock<webrtc::MockAsyncDnsResolverFactory>>(); std::make_unique<NiceMock<MockAsyncDnsResolverFactory>>();
auto callee_async_resolver = auto callee_async_resolver =
std::make_unique<NiceMock<MockAsyncDnsResolver>>(); std::make_unique<NiceMock<MockAsyncDnsResolver>>();
auto caller_async_resolver = auto caller_async_resolver =
@ -1695,12 +1692,12 @@ TEST_P(PeerConnectionIntegrationTest,
// P2PTransportChannel. // P2PTransportChannel.
EXPECT_CALL(*caller_resolver_factory, Create()) EXPECT_CALL(*caller_resolver_factory, Create())
.WillOnce(Return(ByMove(std::move(caller_async_resolver)))); .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); caller_deps.async_dns_resolver_factory = std::move(caller_resolver_factory);
EXPECT_CALL(*callee_resolver_factory, Create()) EXPECT_CALL(*callee_resolver_factory, Create())
.WillOnce(Return(ByMove(std::move(callee_async_resolver)))); .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); callee_deps.async_dns_resolver_factory = std::move(callee_resolver_factory);
PeerConnectionInterface::RTCConfiguration config; PeerConnectionInterface::RTCConfiguration config;
@ -1719,9 +1716,9 @@ TEST_P(PeerConnectionIntegrationTest,
// Enable hostname candidates with mDNS names. // Enable hostname candidates with mDNS names.
caller()->SetMdnsResponder( caller()->SetMdnsResponder(
std::make_unique<webrtc::FakeMdnsResponder>(network_thread())); std::make_unique<FakeMdnsResponder>(network_thread()));
callee()->SetMdnsResponder( callee()->SetMdnsResponder(
std::make_unique<webrtc::FakeMdnsResponder>(network_thread())); std::make_unique<FakeMdnsResponder>(network_thread()));
SetPortAllocatorFlags(kOnlyLocalPorts, kOnlyLocalPorts); SetPortAllocatorFlags(kOnlyLocalPorts, kOnlyLocalPorts);
@ -1730,18 +1727,18 @@ TEST_P(PeerConnectionIntegrationTest,
callee()->AddAudioVideoTracks(); callee()->AddAudioVideoTracks();
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
caller()->ice_connection_state(), kDefaultTimeout); caller()->ice_connection_state(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kDefaultTimeout); callee()->ice_connection_state(), kDefaultTimeout);
// Part of reporting the stats will occur on the network thread, so flush it // Part of reporting the stats will occur on the network thread, so flush it
// before checking NumEvents. // before checking NumEvents.
SendTask(network_thread(), [] {}); SendTask(network_thread(), [] {});
EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents( EXPECT_METRIC_EQ(
"WebRTC.PeerConnection.CandidatePairType_UDP", 1, metrics::NumEvents("WebRTC.PeerConnection.CandidatePairType_UDP",
webrtc::kIceCandidatePairHostNameHostName)); kIceCandidatePairHostNameHostName));
DestroyPeerConnections(); DestroyPeerConnections();
} }
@ -1862,9 +1859,9 @@ TEST_P(PeerConnectionIntegrationIceStatesTest, MAYBE_VerifyBestConnection) {
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
caller()->ice_connection_state(), kDefaultTimeout); caller()->ice_connection_state(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kDefaultTimeout); callee()->ice_connection_state(), kDefaultTimeout);
// Part of reporting the stats will occur on the network thread, so flush it // 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(), [] {}); SendTask(network_thread(), [] {});
// TODO(bugs.webrtc.org/9456): Fix it. // TODO(bugs.webrtc.org/9456): Fix it.
const int num_best_ipv4 = webrtc::metrics::NumEvents( const int num_best_ipv4 = metrics::NumEvents(
"WebRTC.PeerConnection.IPMetrics", webrtc::kBestConnections_IPv4); "WebRTC.PeerConnection.IPMetrics", kBestConnections_IPv4);
const int num_best_ipv6 = webrtc::metrics::NumEvents( const int num_best_ipv6 = metrics::NumEvents(
"WebRTC.PeerConnection.IPMetrics", webrtc::kBestConnections_IPv6); "WebRTC.PeerConnection.IPMetrics", kBestConnections_IPv6);
if (TestIPv6()) { if (TestIPv6()) {
// When IPv6 is enabled, we should prefer an IPv6 connection over an IPv4 // When IPv6 is enabled, we should prefer an IPv6 connection over an IPv4
// connection. // connection.
@ -1886,12 +1883,12 @@ TEST_P(PeerConnectionIntegrationIceStatesTest, MAYBE_VerifyBestConnection) {
EXPECT_METRIC_EQ(0, num_best_ipv6); EXPECT_METRIC_EQ(0, num_best_ipv6);
} }
EXPECT_METRIC_EQ(0, webrtc::metrics::NumEvents( EXPECT_METRIC_EQ(
"WebRTC.PeerConnection.CandidatePairType_UDP", 0, metrics::NumEvents("WebRTC.PeerConnection.CandidatePairType_UDP",
webrtc::kIceCandidatePairHostHost)); kIceCandidatePairHostHost));
EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents( EXPECT_METRIC_EQ(
"WebRTC.PeerConnection.CandidatePairType_UDP", 1, metrics::NumEvents("WebRTC.PeerConnection.CandidatePairType_UDP",
webrtc::kIceCandidatePairHostPublicHostPublic)); kIceCandidatePairHostPublicHostPublic));
} }
constexpr uint32_t kFlagsIPv4NoStun = cricket::PORTALLOCATOR_DISABLE_TCP | constexpr uint32_t kFlagsIPv4NoStun = cricket::PORTALLOCATOR_DISABLE_TCP |
@ -1931,17 +1928,17 @@ TEST_P(PeerConnectionIntegrationTest, MediaContinuesFlowingAfterIceRestart) {
callee()->AddAudioVideoTracks(); callee()->AddAudioVideoTracks();
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
caller()->ice_connection_state(), kMaxWaitForFramesMs); caller()->ice_connection_state(), kMaxWaitForFramesMs);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kMaxWaitForFramesMs); callee()->ice_connection_state(), kMaxWaitForFramesMs);
// To verify that the ICE restart actually occurs, get // To verify that the ICE restart actually occurs, get
// ufrag/password/candidates before and after restart. // ufrag/password/candidates before and after restart.
// Create an SDP string of the first audio candidate for both clients. // 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); caller()->pc()->local_description()->candidates(0);
const webrtc::IceCandidateCollection* audio_candidates_callee = const IceCandidateCollection* audio_candidates_callee =
callee()->pc()->local_description()->candidates(0); callee()->pc()->local_description()->candidates(0);
ASSERT_GT(audio_candidates_caller->count(), 0u); ASSERT_GT(audio_candidates_caller->count(), 0u);
ASSERT_GT(audio_candidates_callee->count(), 0u); ASSERT_GT(audio_candidates_callee->count(), 0u);
@ -1964,9 +1961,9 @@ TEST_P(PeerConnectionIntegrationTest, MediaContinuesFlowingAfterIceRestart) {
caller()->SetOfferAnswerOptions(IceRestartOfferAnswerOptions()); caller()->SetOfferAnswerOptions(IceRestartOfferAnswerOptions());
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
caller()->ice_connection_state(), kMaxWaitForFramesMs); caller()->ice_connection_state(), kMaxWaitForFramesMs);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kMaxWaitForFramesMs); callee()->ice_connection_state(), kMaxWaitForFramesMs);
// Grab the ufrags/candidates again. // Grab the ufrags/candidates again.
@ -2141,9 +2138,9 @@ TEST_F(PeerConnectionIntegrationTestPlanB,
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kMaxWaitForActivationMs); ASSERT_TRUE_WAIT(SignalingStateStable(), kMaxWaitForActivationMs);
// Wait for ICE to complete, without any tracks being set. // 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); caller()->ice_connection_state(), kMaxWaitForFramesMs);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kMaxWaitForFramesMs); callee()->ice_connection_state(), kMaxWaitForFramesMs);
// Now set the tracks, and expect frames to immediately start flowing. // Now set the tracks, and expect frames to immediately start flowing.
EXPECT_TRUE( EXPECT_TRUE(
@ -2182,9 +2179,9 @@ TEST_F(PeerConnectionIntegrationTestUnifiedPlan,
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kMaxWaitForActivationMs); ASSERT_TRUE_WAIT(SignalingStateStable(), kMaxWaitForActivationMs);
// Wait for ICE to complete, without any tracks being set. // 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); caller()->ice_connection_state(), kMaxWaitForFramesMs);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kMaxWaitForFramesMs); callee()->ice_connection_state(), kMaxWaitForFramesMs);
// Now set the tracks, and expect frames to immediately start flowing. // Now set the tracks, and expect frames to immediately start flowing.
auto callee_audio_sender = callee()->pc()->GetSenders()[0]; auto callee_audio_sender = callee()->pc()->GetSenders()[0];
@ -2279,21 +2276,21 @@ TEST_P(PeerConnectionIntegrationTestWithFakeClock,
}); });
PeerConnectionInterface::RTCConfiguration client_1_config; 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.urls.push_back("turn:88.88.88.0:3478");
ice_server_1.username = "test"; ice_server_1.username = "test";
ice_server_1.password = "test"; ice_server_1.password = "test";
client_1_config.servers.push_back(ice_server_1); 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; client_1_config.presume_writable_when_fully_relayed = true;
PeerConnectionInterface::RTCConfiguration client_2_config; 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.urls.push_back("turn:99.99.99.0:3478");
ice_server_2.username = "test"; ice_server_2.username = "test";
ice_server_2.password = "test"; ice_server_2.password = "test";
client_2_config.servers.push_back(ice_server_2); 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; client_2_config.presume_writable_when_fully_relayed = true;
ASSERT_TRUE( ASSERT_TRUE(
@ -2326,22 +2323,22 @@ TEST_P(PeerConnectionIntegrationTestWithFakeClock,
caller()->AddAudioTrack(); caller()->AddAudioTrack();
// Call getStats, assert there are no candidates. // Call getStats, assert there are no candidates.
rtc::scoped_refptr<const webrtc::RTCStatsReport> first_report = rtc::scoped_refptr<const RTCStatsReport> first_report =
caller()->NewGetStats(); caller()->NewGetStats();
ASSERT_TRUE(first_report); ASSERT_TRUE(first_report);
auto first_candidate_stats = auto first_candidate_stats =
first_report->GetStatsOfType<webrtc::RTCLocalIceCandidateStats>(); first_report->GetStatsOfType<RTCLocalIceCandidateStats>();
ASSERT_EQ(first_candidate_stats.size(), 0u); ASSERT_EQ(first_candidate_stats.size(), 0u);
// Create an offer at the caller and set it as remote description on the // Create an offer at the caller and set it as remote description on the
// callee. // callee.
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
// Call getStats again, assert there are candidates now. // 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(); caller()->NewGetStats();
ASSERT_TRUE(second_report); ASSERT_TRUE(second_report);
auto second_candidate_stats = auto second_candidate_stats =
second_report->GetStatsOfType<webrtc::RTCLocalIceCandidateStats>(); second_report->GetStatsOfType<RTCLocalIceCandidateStats>();
ASSERT_NE(second_candidate_stats.size(), 0u); ASSERT_NE(second_candidate_stats.size(), 0u);
// The fake clock ensures that no time has passed so the cache must have been // The fake clock ensures that no time has passed so the cache must have been
@ -2362,17 +2359,17 @@ TEST_P(PeerConnectionIntegrationTestWithFakeClock,
kDefaultTimeout, FakeClock()); kDefaultTimeout, FakeClock());
// Call getStats, assert there are no candidates. // Call getStats, assert there are no candidates.
rtc::scoped_refptr<const webrtc::RTCStatsReport> first_report = rtc::scoped_refptr<const RTCStatsReport> first_report =
caller()->NewGetStats(); caller()->NewGetStats();
ASSERT_TRUE(first_report); ASSERT_TRUE(first_report);
auto first_candidate_stats = auto first_candidate_stats =
first_report->GetStatsOfType<webrtc::RTCRemoteIceCandidateStats>(); first_report->GetStatsOfType<RTCRemoteIceCandidateStats>();
ASSERT_EQ(first_candidate_stats.size(), 0u); ASSERT_EQ(first_candidate_stats.size(), 0u);
// Add a "fake" candidate. // Add a "fake" candidate.
absl::optional<RTCError> result; absl::optional<RTCError> result;
caller()->pc()->AddIceCandidate( caller()->pc()->AddIceCandidate(
absl::WrapUnique(webrtc::CreateIceCandidate( absl::WrapUnique(CreateIceCandidate(
"", 0, "", 0,
"candidate:2214029314 1 udp 2122260223 127.0.0.1 49152 typ host", "candidate:2214029314 1 udp 2122260223 127.0.0.1 49152 typ host",
nullptr)), nullptr)),
@ -2381,11 +2378,11 @@ TEST_P(PeerConnectionIntegrationTestWithFakeClock,
ASSERT_TRUE(result.value().ok()); ASSERT_TRUE(result.value().ok());
// Call getStats again, assert there is a remote candidate now. // 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(); caller()->NewGetStats();
ASSERT_TRUE(second_report); ASSERT_TRUE(second_report);
auto second_candidate_stats = auto second_candidate_stats =
second_report->GetStatsOfType<webrtc::RTCRemoteIceCandidateStats>(); second_report->GetStatsOfType<RTCRemoteIceCandidateStats>();
ASSERT_EQ(second_candidate_stats.size(), 1u); ASSERT_EQ(second_candidate_stats.size(), 1u);
// The fake clock ensures that no time has passed so the cache must have been // 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); turn_server_2_external_address);
PeerConnectionInterface::RTCConfiguration client_1_config; 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.urls.push_back("turn:88.88.88.0:3478");
ice_server_1.username = "test"; ice_server_1.username = "test";
ice_server_1.password = "test"; ice_server_1.password = "test";
client_1_config.servers.push_back(ice_server_1); 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(); auto* customizer1 = CreateTurnCustomizer();
client_1_config.turn_customizer = customizer1; client_1_config.turn_customizer = customizer1;
PeerConnectionInterface::RTCConfiguration client_2_config; 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.urls.push_back("turn:99.99.99.0:3478");
ice_server_2.username = "test"; ice_server_2.username = "test";
ice_server_2.password = "test"; ice_server_2.password = "test";
client_2_config.servers.push_back(ice_server_2); 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(); auto* customizer2 = CreateTurnCustomizer();
client_2_config.turn_customizer = customizer2; client_2_config.turn_customizer = customizer2;
@ -2460,18 +2457,18 @@ TEST_P(PeerConnectionIntegrationTest, TCPUsedForTurnConnections) {
CreateTurnServer(turn_server_internal_address, turn_server_external_address, CreateTurnServer(turn_server_internal_address, turn_server_external_address,
cricket::PROTO_TCP); 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.urls.push_back("turn:88.88.88.0:3478?transport=tcp");
ice_server.username = "test"; ice_server.username = "test";
ice_server.password = "test"; ice_server.password = "test";
PeerConnectionInterface::RTCConfiguration client_1_config; PeerConnectionInterface::RTCConfiguration client_1_config;
client_1_config.servers.push_back(ice_server); 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; PeerConnectionInterface::RTCConfiguration client_2_config;
client_2_config.servers.push_back(ice_server); client_2_config.servers.push_back(ice_server);
client_2_config.type = webrtc::PeerConnectionInterface::kRelay; client_2_config.type = PeerConnectionInterface::kRelay;
ASSERT_TRUE( ASSERT_TRUE(
CreatePeerConnectionWrappersWithConfig(client_1_config, client_2_config)); CreatePeerConnectionWrappersWithConfig(client_1_config, client_2_config));
@ -2482,7 +2479,7 @@ TEST_P(PeerConnectionIntegrationTest, TCPUsedForTurnConnections) {
callee()->AddAudioVideoTracks(); callee()->AddAudioVideoTracks();
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kMaxWaitForFramesMs); callee()->ice_connection_state(), kMaxWaitForFramesMs);
MediaExpectations media_expectations; MediaExpectations media_expectations;
@ -2506,20 +2503,20 @@ TEST_P(PeerConnectionIntegrationTest,
CreateTurnServer(turn_server_internal_address, turn_server_external_address, CreateTurnServer(turn_server_internal_address, turn_server_external_address,
cricket::PROTO_TLS, "88.88.88.0"); 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.urls.push_back("turns:88.88.88.0:3478?transport=tcp");
ice_server.username = "test"; ice_server.username = "test";
ice_server.password = "test"; ice_server.password = "test";
PeerConnectionInterface::RTCConfiguration client_1_config; PeerConnectionInterface::RTCConfiguration client_1_config;
client_1_config.servers.push_back(ice_server); 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; PeerConnectionInterface::RTCConfiguration client_2_config;
client_2_config.servers.push_back(ice_server); client_2_config.servers.push_back(ice_server);
// Setting the type to kRelay forces the connection to go through a TURN // Setting the type to kRelay forces the connection to go through a TURN
// server. // 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. // Get a copy to the pointer so we can verify calls later.
rtc::TestCertificateVerifier* client_1_cert_verifier = rtc::TestCertificateVerifier* client_1_cert_verifier =
@ -2530,10 +2527,10 @@ TEST_P(PeerConnectionIntegrationTest,
client_2_cert_verifier->verify_certificate_ = true; client_2_cert_verifier->verify_certificate_ = true;
// Create the dependencies with the test certificate verifier. // 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 = client_1_deps.tls_cert_verifier =
std::unique_ptr<rtc::TestCertificateVerifier>(client_1_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 = client_2_deps.tls_cert_verifier =
std::unique_ptr<rtc::TestCertificateVerifier>(client_2_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); ASSERT_GT(receiver->GetParameters().encodings.size(), 0u);
EXPECT_EQ(receiver->GetParameters().encodings[0].ssrc, EXPECT_EQ(receiver->GetParameters().encodings[0].ssrc,
sources[0].source_id()); 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) { TEST_P(PeerConnectionIntegrationTest, GetSourcesVideo) {
@ -2665,7 +2662,7 @@ TEST_P(PeerConnectionIntegrationTest, GetSourcesVideo) {
ASSERT_GT(sources.size(), 0u); ASSERT_GT(sources.size(), 0u);
EXPECT_EQ(receiver->GetParameters().encodings[0].ssrc, EXPECT_EQ(receiver->GetParameters().encodings[0].ssrc,
sources[0].source_id()); 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) { TEST_P(PeerConnectionIntegrationTest, UnsignaledSsrcGetSourcesAudio) {
@ -2684,7 +2681,7 @@ TEST_P(PeerConnectionIntegrationTest, UnsignaledSsrcGetSourcesAudio) {
})(), })(),
kDefaultTimeout); kDefaultTimeout);
ASSERT_GT(sources.size(), 0u); 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) { TEST_P(PeerConnectionIntegrationTest, UnsignaledSsrcGetSourcesVideo) {
@ -2703,7 +2700,7 @@ TEST_P(PeerConnectionIntegrationTest, UnsignaledSsrcGetSourcesVideo) {
})(), })(),
kDefaultTimeout); kDefaultTimeout);
ASSERT_GT(sources.size(), 0u); 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 // 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(); std::vector<RtpSource> sources = receiver->GetSources();
// SSRC history must not be cleared since the reception of the first frame. // SSRC history must not be cleared since the reception of the first frame.
ASSERT_GT(sources.size(), 0u); 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) { TEST_P(PeerConnectionIntegrationTest, UnsignaledSsrcGetParametersAudio) {
@ -2791,9 +2788,9 @@ TEST_F(PeerConnectionIntegrationTestPlanB, RemoveAndAddTrackWithNewStreamId) {
ConnectFakeSignaling(); ConnectFakeSignaling();
// Add track using stream 1, do offer/answer. // Add track using stream 1, do offer/answer.
rtc::scoped_refptr<webrtc::AudioTrackInterface> track = rtc::scoped_refptr<AudioTrackInterface> track =
caller()->CreateLocalAudioTrack(); caller()->CreateLocalAudioTrack();
rtc::scoped_refptr<webrtc::RtpSenderInterface> sender = rtc::scoped_refptr<RtpSenderInterface> sender =
caller()->AddTrack(track, {"stream_1"}); caller()->AddTrack(track, {"stream_1"});
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
@ -2825,8 +2822,8 @@ TEST_P(PeerConnectionIntegrationTest, RtcEventLogOutputWriteCalled) {
.WillByDefault(::testing::Return(true)); .WillByDefault(::testing::Return(true));
EXPECT_CALL(*output, Write(::testing::A<absl::string_view>())) EXPECT_CALL(*output, Write(::testing::A<absl::string_view>()))
.Times(::testing::AtLeast(1)); .Times(::testing::AtLeast(1));
EXPECT_TRUE(caller()->pc()->StartRtcEventLog( EXPECT_TRUE(caller()->pc()->StartRtcEventLog(std::move(output),
std::move(output), webrtc::RtcEventLog::kImmediateOutput)); RtcEventLog::kImmediateOutput));
caller()->AddAudioVideoTracks(); caller()->AddAudioVideoTracks();
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
@ -2900,8 +2897,7 @@ TEST_P(PeerConnectionIntegrationTest, DisableAndEnableAudioPlayout) {
double GetAudioEnergyStat(PeerConnectionIntegrationWrapper* pc) { double GetAudioEnergyStat(PeerConnectionIntegrationWrapper* pc) {
auto report = pc->NewGetStats(); auto report = pc->NewGetStats();
auto inbound_rtps = auto inbound_rtps = report->GetStatsOfType<RTCInboundRtpStreamStats>();
report->GetStatsOfType<webrtc::RTCInboundRtpStreamStats>();
RTC_CHECK(!inbound_rtps.empty()); RTC_CHECK(!inbound_rtps.empty());
auto* inbound_rtp = inbound_rtps[0]; auto* inbound_rtp = inbound_rtps[0];
if (!inbound_rtp->total_audio_energy.is_defined()) { if (!inbound_rtp->total_audio_energy.is_defined()) {
@ -2974,20 +2970,20 @@ TEST_P(PeerConnectionIntegrationTest,
ASSERT_TRUE_WAIT(DtlsConnected(), kDefaultTimeout); ASSERT_TRUE_WAIT(DtlsConnected(), kDefaultTimeout);
ASSERT_NE(nullptr, caller()->event_log_factory()); ASSERT_NE(nullptr, caller()->event_log_factory());
ASSERT_NE(nullptr, callee()->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(); caller()->event_log_factory()->last_log_created();
webrtc::FakeRtcEventLog* callee_event_log = FakeRtcEventLog* callee_event_log =
callee()->event_log_factory()->last_log_created(); callee()->event_log_factory()->last_log_created();
ASSERT_NE(nullptr, caller_event_log); ASSERT_NE(nullptr, caller_event_log);
ASSERT_NE(nullptr, callee_event_log); ASSERT_NE(nullptr, callee_event_log);
int caller_ice_config_count = caller_event_log->GetEventCount( int caller_ice_config_count =
webrtc::RtcEvent::Type::IceCandidatePairConfig); caller_event_log->GetEventCount(RtcEvent::Type::IceCandidatePairConfig);
int caller_ice_event_count = caller_event_log->GetEventCount( int caller_ice_event_count =
webrtc::RtcEvent::Type::IceCandidatePairEvent); caller_event_log->GetEventCount(RtcEvent::Type::IceCandidatePairEvent);
int callee_ice_config_count = callee_event_log->GetEventCount( int callee_ice_config_count =
webrtc::RtcEvent::Type::IceCandidatePairConfig); callee_event_log->GetEventCount(RtcEvent::Type::IceCandidatePairConfig);
int callee_ice_event_count = callee_event_log->GetEventCount( int callee_ice_event_count =
webrtc::RtcEvent::Type::IceCandidatePairEvent); callee_event_log->GetEventCount(RtcEvent::Type::IceCandidatePairEvent);
EXPECT_LT(0, caller_ice_config_count); EXPECT_LT(0, caller_ice_config_count);
EXPECT_LT(0, caller_ice_event_count); EXPECT_LT(0, caller_ice_event_count);
EXPECT_LT(0, callee_ice_config_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); 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.urls.push_back("turn:88.88.88.0:3478");
ice_server.username = "test"; ice_server.username = "test";
ice_server.password = "test"; ice_server.password = "test";
PeerConnectionInterface::RTCConfiguration caller_config; PeerConnectionInterface::RTCConfiguration caller_config;
caller_config.servers.push_back(ice_server); 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.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
caller_config.surface_ice_candidates_on_ice_transport_type_changed = true; caller_config.surface_ice_candidates_on_ice_transport_type_changed = true;
PeerConnectionInterface::RTCConfiguration callee_config; PeerConnectionInterface::RTCConfiguration callee_config;
callee_config.servers.push_back(ice_server); 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.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
callee_config.surface_ice_candidates_on_ice_transport_type_changed = true; callee_config.surface_ice_candidates_on_ice_transport_type_changed = true;
@ -3031,9 +3027,9 @@ TEST_P(PeerConnectionIntegrationTest, RegatherAfterChangingIceTransportType) {
// kIceGatheringComplete (see // kIceGatheringComplete (see
// P2PTransportChannel::OnCandidatesAllocationDone), and consequently not // P2PTransportChannel::OnCandidatesAllocationDone), and consequently not
// kIceConnectionComplete. // kIceConnectionComplete.
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
caller()->ice_connection_state(), kDefaultTimeout); caller()->ice_connection_state(), kDefaultTimeout);
EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected, EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
callee()->ice_connection_state(), kDefaultTimeout); callee()->ice_connection_state(), kDefaultTimeout);
// Note that we cannot use the metric // Note that we cannot use the metric
// `WebRTC.PeerConnection.CandidatePairType_UDP` in this test since this // `WebRTC.PeerConnection.CandidatePairType_UDP` in this test since this
@ -3046,7 +3042,7 @@ TEST_P(PeerConnectionIntegrationTest, RegatherAfterChangingIceTransportType) {
// Loosen the caller's candidate filter. // Loosen the caller's candidate filter.
caller_config = caller()->pc()->GetConfiguration(); caller_config = caller()->pc()->GetConfiguration();
caller_config.type = webrtc::PeerConnectionInterface::kAll; caller_config.type = PeerConnectionInterface::kAll;
caller()->pc()->SetConfiguration(caller_config); caller()->pc()->SetConfiguration(caller_config);
// We should have gathered a new host candidate. // We should have gathered a new host candidate.
EXPECT_EQ_WAIT(cricket::LOCAL_PORT_TYPE, EXPECT_EQ_WAIT(cricket::LOCAL_PORT_TYPE,
@ -3054,7 +3050,7 @@ TEST_P(PeerConnectionIntegrationTest, RegatherAfterChangingIceTransportType) {
// Loosen the callee's candidate filter. // Loosen the callee's candidate filter.
callee_config = callee()->pc()->GetConfiguration(); callee_config = callee()->pc()->GetConfiguration();
callee_config.type = webrtc::PeerConnectionInterface::kAll; callee_config.type = PeerConnectionInterface::kAll;
callee()->pc()->SetConfiguration(callee_config); callee()->pc()->SetConfiguration(callee_config);
EXPECT_EQ_WAIT(cricket::LOCAL_PORT_TYPE, EXPECT_EQ_WAIT(cricket::LOCAL_PORT_TYPE,
callee()->last_candidate_gathered().type(), kDefaultTimeout); callee()->last_candidate_gathered().type(), kDefaultTimeout);
@ -3084,19 +3080,19 @@ TEST_P(PeerConnectionIntegrationTest, OnIceCandidateError) {
CreateTurnServer(turn_server_internal_address, turn_server_external_address); 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.urls.push_back("turn:88.88.88.0:3478");
ice_server.username = "test"; ice_server.username = "test";
ice_server.password = "123"; ice_server.password = "123";
PeerConnectionInterface::RTCConfiguration caller_config; PeerConnectionInterface::RTCConfiguration caller_config;
caller_config.servers.push_back(ice_server); 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.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
PeerConnectionInterface::RTCConfiguration callee_config; PeerConnectionInterface::RTCConfiguration callee_config;
callee_config.servers.push_back(ice_server); 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.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
ASSERT_TRUE( ASSERT_TRUE(
@ -3115,19 +3111,19 @@ TEST_P(PeerConnectionIntegrationTest, OnIceCandidateError) {
} }
TEST_P(PeerConnectionIntegrationTest, OnIceCandidateErrorWithEmptyAddress) { 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.urls.push_back("turn:127.0.0.1:3478?transport=tcp");
ice_server.username = "test"; ice_server.username = "test";
ice_server.password = "test"; ice_server.password = "test";
PeerConnectionInterface::RTCConfiguration caller_config; PeerConnectionInterface::RTCConfiguration caller_config;
caller_config.servers.push_back(ice_server); 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.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
PeerConnectionInterface::RTCConfiguration callee_config; PeerConnectionInterface::RTCConfiguration callee_config;
callee_config.servers.push_back(ice_server); 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.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
ASSERT_TRUE( ASSERT_TRUE(
@ -3697,7 +3693,7 @@ TEST_P(PeerConnectionIntegrationTest, EndToEndRtpSenderVideoEncoderSelector) {
CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/true)); CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/true));
ConnectFakeSignaling(); ConnectFakeSignaling();
// Add one-directional video, from caller to callee. // Add one-directional video, from caller to callee.
rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track = rtc::scoped_refptr<VideoTrackInterface> caller_track =
caller()->CreateLocalVideoTrack(); caller()->CreateLocalVideoTrack();
auto sender = caller()->AddTrack(caller_track); auto sender = caller()->AddTrack(caller_track);
PeerConnectionInterface::RTCOfferAnswerOptions options; PeerConnectionInterface::RTCOfferAnswerOptions options;
@ -3722,7 +3718,7 @@ TEST_P(PeerConnectionIntegrationTest, EndToEndRtpSenderVideoEncoderSelector) {
} }
int NacksReceivedCount(PeerConnectionIntegrationWrapper& pc) { 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>(); auto sender_stats = report->GetStatsOfType<RTCOutboundRtpStreamStats>();
if (sender_stats.size() != 1) { if (sender_stats.size() != 1) {
ADD_FAILURE(); ADD_FAILURE();
@ -3735,7 +3731,7 @@ int NacksReceivedCount(PeerConnectionIntegrationWrapper& pc) {
} }
int NacksSentCount(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>(); auto receiver_stats = report->GetStatsOfType<RTCInboundRtpStreamStats>();
if (receiver_stats.size() != 1) { if (receiver_stats.size() != 1) {
ADD_FAILURE(); 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 // Get the ufrags out of an SDP blob. Useful for testing ICE restart
// behavior. // behavior.
std::vector<std::string> GetUfrags( std::vector<std::string> GetUfrags(const SessionDescriptionInterface* desc) {
const webrtc::SessionDescriptionInterface* desc) {
std::vector<std::string> ufrags; std::vector<std::string> ufrags;
for (const cricket::TransportInfo& info : for (const cricket::TransportInfo& info :
desc->description()->transport_infos()) { desc->description()->transport_infos()) {
@ -544,21 +543,19 @@ rtc::scoped_refptr<StreamCollection> CreateStreamCollection(
StreamCollection::Create()); StreamCollection::Create());
for (int i = 0; i < number_of_streams; ++i) { for (int i = 0; i < number_of_streams; ++i) {
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream( rtc::scoped_refptr<MediaStreamInterface> stream(
webrtc::MediaStream::Create(kStreams[i])); MediaStream::Create(kStreams[i]));
for (int j = 0; j < tracks_per_stream; ++j) { for (int j = 0; j < tracks_per_stream; ++j) {
// Add a local audio track. // Add a local audio track.
rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track( rtc::scoped_refptr<AudioTrackInterface> audio_track(
webrtc::AudioTrack::Create(kAudioTracks[i * tracks_per_stream + j], AudioTrack::Create(kAudioTracks[i * tracks_per_stream + j], nullptr));
nullptr));
stream->AddTrack(audio_track); stream->AddTrack(audio_track);
// Add a local video track. // Add a local video track.
rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track( rtc::scoped_refptr<VideoTrackInterface> video_track(VideoTrack::Create(
webrtc::VideoTrack::Create(kVideoTracks[i * tracks_per_stream + j], kVideoTracks[i * tracks_per_stream + j],
webrtc::FakeVideoTrackSource::Create(), FakeVideoTrackSource::Create(), rtc::Thread::Current()));
rtc::Thread::Current()));
stream->AddTrack(video_track); stream->AddTrack(video_track);
} }
@ -578,10 +575,10 @@ bool CompareStreamCollections(StreamCollectionInterface* s1,
if (s1->at(i)->id() != s2->at(i)->id()) { if (s1->at(i)->id() != s2->at(i)->id()) {
return false; return false;
} }
webrtc::AudioTrackVector audio_tracks1 = s1->at(i)->GetAudioTracks(); AudioTrackVector audio_tracks1 = s1->at(i)->GetAudioTracks();
webrtc::AudioTrackVector audio_tracks2 = s2->at(i)->GetAudioTracks(); AudioTrackVector audio_tracks2 = s2->at(i)->GetAudioTracks();
webrtc::VideoTrackVector video_tracks1 = s1->at(i)->GetVideoTracks(); VideoTrackVector video_tracks1 = s1->at(i)->GetVideoTracks();
webrtc::VideoTrackVector video_tracks2 = s2->at(i)->GetVideoTracks(); VideoTrackVector video_tracks2 = s2->at(i)->GetVideoTracks();
if (audio_tracks1.size() != audio_tracks2.size()) { if (audio_tracks1.size() != audio_tracks2.size()) {
return false; return false;
@ -630,7 +627,7 @@ class MockTrackObserver : public ObserverInterface {
// constraints are propagated into the PeerConnection's MediaConfig. These // constraints are propagated into the PeerConnection's MediaConfig. These
// settings are intended for MediaChannel constructors, but that is not // settings are intended for MediaChannel constructors, but that is not
// exercised by these unittest. // exercised by these unittest.
class PeerConnectionFactoryForTest : public webrtc::PeerConnectionFactory { class PeerConnectionFactoryForTest : public PeerConnectionFactory {
public: public:
static rtc::scoped_refptr<PeerConnectionFactoryForTest> static rtc::scoped_refptr<PeerConnectionFactoryForTest>
CreatePeerConnectionFactoryForTest() { CreatePeerConnectionFactoryForTest() {
@ -665,7 +662,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
main_(vss_.get()), main_(vss_.get()),
sdp_semantics_(sdp_semantics) { sdp_semantics_(sdp_semantics) {
#ifdef WEBRTC_ANDROID #ifdef WEBRTC_ANDROID
webrtc::InitializeAndroidObjects(); InitializeAndroidObjects();
#endif #endif
} }
@ -673,22 +670,16 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
// Use fake audio capture module since we're only testing the interface // 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. // level, and using a real one could make tests flaky when run in parallel.
fake_audio_capture_module_ = FakeAudioCaptureModule::Create(); fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
pc_factory_ = webrtc::CreatePeerConnectionFactory( pc_factory_ = CreatePeerConnectionFactory(
rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
rtc::scoped_refptr<webrtc::AudioDeviceModule>( rtc::scoped_refptr<AudioDeviceModule>(fake_audio_capture_module_),
fake_audio_capture_module_), CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
webrtc::CreateBuiltinAudioEncoderFactory(), std::make_unique<VideoEncoderFactoryTemplate<
webrtc::CreateBuiltinAudioDecoderFactory(), LibvpxVp8EncoderTemplateAdapter, LibvpxVp9EncoderTemplateAdapter,
std::make_unique<webrtc::VideoEncoderFactoryTemplate< OpenH264EncoderTemplateAdapter, LibaomAv1EncoderTemplateAdapter>>(),
webrtc::LibvpxVp8EncoderTemplateAdapter, std::make_unique<VideoDecoderFactoryTemplate<
webrtc::LibvpxVp9EncoderTemplateAdapter, LibvpxVp8DecoderTemplateAdapter, LibvpxVp9DecoderTemplateAdapter,
webrtc::OpenH264EncoderTemplateAdapter, OpenH264DecoderTemplateAdapter, Dav1dDecoderTemplateAdapter>>(),
webrtc::LibaomAv1EncoderTemplateAdapter>>(),
std::make_unique<webrtc::VideoDecoderFactoryTemplate<
webrtc::LibvpxVp8DecoderTemplateAdapter,
webrtc::LibvpxVp9DecoderTemplateAdapter,
webrtc::OpenH264DecoderTemplateAdapter,
webrtc::Dav1dDecoderTemplateAdapter>>(),
nullptr /* audio_mixer */, nullptr /* audio_processing */); nullptr /* audio_mixer */, nullptr /* audio_processing */);
ASSERT_TRUE(pc_factory_); ASSERT_TRUE(pc_factory_);
} }
@ -946,8 +937,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
// Call the standards-compliant GetStats function. // Call the standards-compliant GetStats function.
bool DoGetRTCStats() { bool DoGetRTCStats() {
auto callback = auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>();
rtc::make_ref_counted<webrtc::MockRTCStatsCollectorCallback>();
pc_->GetStats(callback.get()); pc_->GetStats(callback.get());
EXPECT_TRUE_WAIT(callback->called(), kTimeout); EXPECT_TRUE_WAIT(callback->called(), kTimeout);
return callback->called(); return callback->called();
@ -987,14 +977,14 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
std::string sdp; std::string sdp;
EXPECT_TRUE(offer->ToString(&sdp)); EXPECT_TRUE(offer->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> remote_offer( std::unique_ptr<SessionDescriptionInterface> remote_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp)); CreateSessionDescription(SdpType::kOffer, sdp));
EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer))); EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_); EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
} }
void CreateAndSetRemoteOffer(const std::string& sdp) { void CreateAndSetRemoteOffer(const std::string& sdp) {
std::unique_ptr<SessionDescriptionInterface> remote_offer( std::unique_ptr<SessionDescriptionInterface> remote_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp)); CreateSessionDescription(SdpType::kOffer, sdp));
EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer))); EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_); EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
} }
@ -1013,7 +1003,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
std::string sdp; std::string sdp;
EXPECT_TRUE(answer->ToString(&sdp)); EXPECT_TRUE(answer->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> new_answer( std::unique_ptr<SessionDescriptionInterface> new_answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, sdp)); CreateSessionDescription(SdpType::kAnswer, sdp));
EXPECT_TRUE(DoSetLocalDescription(std::move(new_answer))); EXPECT_TRUE(DoSetLocalDescription(std::move(new_answer)));
EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_); EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
} }
@ -1025,7 +1015,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
std::string sdp; std::string sdp;
EXPECT_TRUE(answer->ToString(&sdp)); EXPECT_TRUE(answer->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> pr_answer( std::unique_ptr<SessionDescriptionInterface> pr_answer(
webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp)); CreateSessionDescription(SdpType::kPrAnswer, sdp));
EXPECT_TRUE(DoSetLocalDescription(std::move(pr_answer))); EXPECT_TRUE(DoSetLocalDescription(std::move(pr_answer)));
EXPECT_EQ(PeerConnectionInterface::kHaveLocalPrAnswer, observer_.state_); EXPECT_EQ(PeerConnectionInterface::kHaveLocalPrAnswer, observer_.state_);
} }
@ -1050,7 +1040,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
std::string sdp; std::string sdp;
EXPECT_TRUE(offer->ToString(&sdp)); EXPECT_TRUE(offer->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> new_offer( std::unique_ptr<SessionDescriptionInterface> new_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp)); CreateSessionDescription(SdpType::kOffer, sdp));
EXPECT_TRUE(DoSetLocalDescription(std::move(new_offer))); EXPECT_TRUE(DoSetLocalDescription(std::move(new_offer)));
EXPECT_EQ(PeerConnectionInterface::kHaveLocalOffer, observer_.state_); EXPECT_EQ(PeerConnectionInterface::kHaveLocalOffer, observer_.state_);
@ -1060,7 +1050,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
void CreateAnswerAsRemoteDescription(const std::string& sdp) { void CreateAnswerAsRemoteDescription(const std::string& sdp) {
std::unique_ptr<SessionDescriptionInterface> answer( std::unique_ptr<SessionDescriptionInterface> answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, sdp)); CreateSessionDescription(SdpType::kAnswer, sdp));
ASSERT_TRUE(answer); ASSERT_TRUE(answer);
EXPECT_TRUE(DoSetRemoteDescription(std::move(answer))); EXPECT_TRUE(DoSetRemoteDescription(std::move(answer)));
EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_); EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
@ -1068,12 +1058,12 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
void CreatePrAnswerAndAnswerAsRemoteDescription(const std::string& sdp) { void CreatePrAnswerAndAnswerAsRemoteDescription(const std::string& sdp) {
std::unique_ptr<SessionDescriptionInterface> pr_answer( std::unique_ptr<SessionDescriptionInterface> pr_answer(
webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp)); CreateSessionDescription(SdpType::kPrAnswer, sdp));
ASSERT_TRUE(pr_answer); ASSERT_TRUE(pr_answer);
EXPECT_TRUE(DoSetRemoteDescription(std::move(pr_answer))); EXPECT_TRUE(DoSetRemoteDescription(std::move(pr_answer)));
EXPECT_EQ(PeerConnectionInterface::kHaveRemotePrAnswer, observer_.state_); EXPECT_EQ(PeerConnectionInterface::kHaveRemotePrAnswer, observer_.state_);
std::unique_ptr<SessionDescriptionInterface> answer( std::unique_ptr<SessionDescriptionInterface> answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, sdp)); CreateSessionDescription(SdpType::kAnswer, sdp));
ASSERT_TRUE(answer); ASSERT_TRUE(answer);
EXPECT_TRUE(DoSetRemoteDescription(std::move(answer))); EXPECT_TRUE(DoSetRemoteDescription(std::move(answer)));
EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_); EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
@ -1117,8 +1107,8 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
std::string mediastream_id = kStreams[0]; std::string mediastream_id = kStreams[0];
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream( rtc::scoped_refptr<MediaStreamInterface> stream(
webrtc::MediaStream::Create(mediastream_id)); MediaStream::Create(mediastream_id));
reference_collection_->AddStream(stream); reference_collection_->AddStream(stream);
if (number_of_audio_tracks > 0) { if (number_of_audio_tracks > 0) {
@ -1142,22 +1132,20 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
} }
return std::unique_ptr<SessionDescriptionInterface>( return std::unique_ptr<SessionDescriptionInterface>(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp_ms1)); CreateSessionDescription(SdpType::kOffer, sdp_ms1));
} }
void AddAudioTrack(const std::string& track_id, void AddAudioTrack(const std::string& track_id,
MediaStreamInterface* stream) { MediaStreamInterface* stream) {
rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track( rtc::scoped_refptr<AudioTrackInterface> audio_track(
webrtc::AudioTrack::Create(track_id, nullptr)); AudioTrack::Create(track_id, nullptr));
ASSERT_TRUE(stream->AddTrack(audio_track)); ASSERT_TRUE(stream->AddTrack(audio_track));
} }
void AddVideoTrack(const std::string& track_id, void AddVideoTrack(const std::string& track_id,
MediaStreamInterface* stream) { MediaStreamInterface* stream) {
rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track( rtc::scoped_refptr<VideoTrackInterface> video_track(VideoTrack::Create(
webrtc::VideoTrack::Create(track_id, track_id, FakeVideoTrackSource::Create(), rtc::Thread::Current()));
webrtc::FakeVideoTrackSource::Create(),
rtc::Thread::Current()));
ASSERT_TRUE(stream->AddTrack(video_track)); ASSERT_TRUE(stream->AddTrack(video_track));
} }
@ -1217,7 +1205,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
std::string sdp; std::string sdp;
EXPECT_TRUE((*desc)->ToString(&sdp)); EXPECT_TRUE((*desc)->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> remote_offer( std::unique_ptr<SessionDescriptionInterface> remote_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp)); CreateSessionDescription(SdpType::kOffer, sdp));
EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer))); EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_); EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
} }
@ -1230,7 +1218,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
std::string sdp; std::string sdp;
EXPECT_TRUE((*desc)->ToString(&sdp)); EXPECT_TRUE((*desc)->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> new_offer( std::unique_ptr<SessionDescriptionInterface> new_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp)); CreateSessionDescription(SdpType::kOffer, sdp));
EXPECT_TRUE(DoSetLocalDescription(std::move(new_offer))); EXPECT_TRUE(DoSetLocalDescription(std::move(new_offer)));
EXPECT_EQ(PeerConnectionInterface::kHaveLocalOffer, observer_.state_); EXPECT_EQ(PeerConnectionInterface::kHaveLocalOffer, observer_.state_);
@ -1266,13 +1254,13 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
rtc::SocketServer* socket_server() const { return vss_.get(); } rtc::SocketServer* socket_server() const { return vss_.get(); }
webrtc::test::ScopedKeyValueConfig field_trials_; test::ScopedKeyValueConfig field_trials_;
std::unique_ptr<rtc::VirtualSocketServer> vss_; std::unique_ptr<rtc::VirtualSocketServer> vss_;
rtc::AutoSocketServerThread main_; rtc::AutoSocketServerThread main_;
rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_; rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
cricket::FakePortAllocator* port_allocator_ = nullptr; cricket::FakePortAllocator* port_allocator_ = nullptr;
FakeRTCCertificateGenerator* fake_certificate_generator_ = nullptr; FakeRTCCertificateGenerator* fake_certificate_generator_ = nullptr;
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory_; rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
rtc::scoped_refptr<PeerConnectionInterface> pc_; rtc::scoped_refptr<PeerConnectionInterface> pc_;
MockPeerConnectionObserver observer_; MockPeerConnectionObserver observer_;
rtc::scoped_refptr<StreamCollection> reference_collection_; rtc::scoped_refptr<StreamCollection> reference_collection_;
@ -1392,22 +1380,19 @@ TEST_P(PeerConnectionInterfaceTest,
config.prune_turn_ports = true; config.prune_turn_ports = true;
// Create the PC factory and PC with the above config. // Create the PC factory and PC with the above config.
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory( rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory(
webrtc::CreatePeerConnectionFactory( CreatePeerConnectionFactory(
rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
rtc::Thread::Current(), fake_audio_capture_module_, rtc::Thread::Current(), fake_audio_capture_module_,
webrtc::CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioEncoderFactory(),
webrtc::CreateBuiltinAudioDecoderFactory(), CreateBuiltinAudioDecoderFactory(),
std::make_unique<webrtc::VideoEncoderFactoryTemplate< std::make_unique<VideoEncoderFactoryTemplate<
webrtc::LibvpxVp8EncoderTemplateAdapter, LibvpxVp8EncoderTemplateAdapter, LibvpxVp9EncoderTemplateAdapter,
webrtc::LibvpxVp9EncoderTemplateAdapter, OpenH264EncoderTemplateAdapter,
webrtc::OpenH264EncoderTemplateAdapter, LibaomAv1EncoderTemplateAdapter>>(),
webrtc::LibaomAv1EncoderTemplateAdapter>>(), std::make_unique<VideoDecoderFactoryTemplate<
std::make_unique<webrtc::VideoDecoderFactoryTemplate< LibvpxVp8DecoderTemplateAdapter, LibvpxVp9DecoderTemplateAdapter,
webrtc::LibvpxVp8DecoderTemplateAdapter, OpenH264DecoderTemplateAdapter, Dav1dDecoderTemplateAdapter>>(),
webrtc::LibvpxVp9DecoderTemplateAdapter,
webrtc::OpenH264DecoderTemplateAdapter,
webrtc::Dav1dDecoderTemplateAdapter>>(),
nullptr /* audio_mixer */, nullptr /* audio_processing */)); nullptr /* audio_mixer */, nullptr /* audio_processing */));
PeerConnectionDependencies pc_dependencies(&observer_); PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.allocator = std::move(port_allocator); 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_TCP);
EXPECT_TRUE(raw_port_allocator->flags() & EXPECT_TRUE(raw_port_allocator->flags() &
cricket::PORTALLOCATOR_DISABLE_COSTLY_NETWORKS); 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()); raw_port_allocator->turn_port_prune_policy());
} }
@ -1446,8 +1431,7 @@ TEST_P(PeerConnectionInterfaceTest, GetConfigurationAfterCreatePeerConnection) {
TEST_P(PeerConnectionInterfaceTest, GetConfigurationAfterSetConfiguration) { TEST_P(PeerConnectionInterfaceTest, GetConfigurationAfterSetConfiguration) {
PeerConnectionInterface::RTCConfiguration starting_config; PeerConnectionInterface::RTCConfiguration starting_config;
starting_config.sdp_semantics = sdp_semantics_; starting_config.sdp_semantics = sdp_semantics_;
starting_config.bundle_policy = starting_config.bundle_policy = PeerConnection::kBundlePolicyMaxBundle;
webrtc::PeerConnection::kBundlePolicyMaxBundle;
CreatePeerConnection(starting_config); CreatePeerConnection(starting_config);
PeerConnectionInterface::RTCConfiguration config = pc_->GetConfiguration(); PeerConnectionInterface::RTCConfiguration config = pc_->GetConfiguration();
@ -1978,7 +1962,7 @@ TEST_P(PeerConnectionInterfaceTest, CreateSctpDataChannel) {
RTCConfiguration rtc_config; RTCConfiguration rtc_config;
CreatePeerConnection(rtc_config); CreatePeerConnection(rtc_config);
webrtc::DataChannelInit config; DataChannelInit config;
auto channel = pc_->CreateDataChannelOrError("1", &config); auto channel = pc_->CreateDataChannelOrError("1", &config);
EXPECT_TRUE(channel.ok()); EXPECT_TRUE(channel.ok());
EXPECT_TRUE(channel.value()->reliable()); EXPECT_TRUE(channel.value()->reliable());
@ -2010,7 +1994,7 @@ TEST_P(PeerConnectionInterfaceTest, CreateSctpDataChannelWhenClosed) {
RTCConfiguration rtc_config; RTCConfiguration rtc_config;
CreatePeerConnection(rtc_config); CreatePeerConnection(rtc_config);
pc_->Close(); pc_->Close();
webrtc::DataChannelInit config; DataChannelInit config;
auto ret = pc_->CreateDataChannelOrError("1", &config); auto ret = pc_->CreateDataChannelOrError("1", &config);
ASSERT_FALSE(ret.ok()); ASSERT_FALSE(ret.ok());
EXPECT_EQ(ret.error().type(), RTCErrorType::INVALID_STATE); EXPECT_EQ(ret.error().type(), RTCErrorType::INVALID_STATE);
@ -2022,7 +2006,7 @@ TEST_P(PeerConnectionInterfaceTest, CreateSctpDataChannelWithMinusOne) {
RTCConfiguration rtc_config; RTCConfiguration rtc_config;
CreatePeerConnection(rtc_config); CreatePeerConnection(rtc_config);
webrtc::DataChannelInit config; DataChannelInit config;
config.maxRetransmitTime = -1; config.maxRetransmitTime = -1;
config.maxRetransmits = -1; config.maxRetransmits = -1;
auto channel = pc_->CreateDataChannelOrError("1", &config); auto channel = pc_->CreateDataChannelOrError("1", &config);
@ -2037,7 +2021,7 @@ TEST_P(PeerConnectionInterfaceTest,
CreatePeerConnection(rtc_config); CreatePeerConnection(rtc_config);
std::string label = "test"; std::string label = "test";
webrtc::DataChannelInit config; DataChannelInit config;
config.maxRetransmits = 0; config.maxRetransmits = 0;
config.maxRetransmitTime = 0; config.maxRetransmitTime = 0;
@ -2052,7 +2036,7 @@ TEST_P(PeerConnectionInterfaceTest,
RTCConfiguration rtc_config; RTCConfiguration rtc_config;
CreatePeerConnection(rtc_config); CreatePeerConnection(rtc_config);
webrtc::DataChannelInit config; DataChannelInit config;
config.id = 1; config.id = 1;
config.negotiated = true; config.negotiated = true;
@ -2106,7 +2090,7 @@ TEST_P(PeerConnectionInterfaceTest, DISABLED_TestRejectSctpDataChannelInAnswer)
std::string sdp; std::string sdp;
EXPECT_TRUE(pc_->local_description()->ToString(&sdp)); EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> answer( std::unique_ptr<SessionDescriptionInterface> answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, sdp)); CreateSessionDescription(SdpType::kAnswer, sdp));
ASSERT_TRUE(answer); ASSERT_TRUE(answer);
cricket::ContentInfo* data_info = cricket::ContentInfo* data_info =
cricket::GetFirstDataContent(answer->description()); cricket::GetFirstDataContent(answer->description());
@ -2125,8 +2109,7 @@ TEST_P(PeerConnectionInterfaceTest, ReceiveFireFoxOffer) {
AddAudioTrack("audio_label"); AddAudioTrack("audio_label");
AddVideoTrack("video_label"); AddVideoTrack("video_label");
std::unique_ptr<SessionDescriptionInterface> desc( std::unique_ptr<SessionDescriptionInterface> desc(
webrtc::CreateSessionDescription(SdpType::kOffer, CreateSessionDescription(SdpType::kOffer, kFireFoxSdpOffer, nullptr));
webrtc::kFireFoxSdpOffer, nullptr));
EXPECT_TRUE(DoSetSessionDescription(std::move(desc), false)); EXPECT_TRUE(DoSetSessionDescription(std::move(desc), false));
CreateAnswerAsLocalDescription(); CreateAnswerAsLocalDescription();
ASSERT_TRUE(pc_->local_description() != nullptr); ASSERT_TRUE(pc_->local_description() != nullptr);
@ -2163,8 +2146,7 @@ TEST_P(PeerConnectionInterfaceTest, DtlsSdesFallbackNotSupported) {
EXPECT_EQ_WAIT(1, fake_certificate_generator_->generated_certificates(), EXPECT_EQ_WAIT(1, fake_certificate_generator_->generated_certificates(),
kTimeout); kTimeout);
std::unique_ptr<SessionDescriptionInterface> desc( std::unique_ptr<SessionDescriptionInterface> desc(
webrtc::CreateSessionDescription(SdpType::kOffer, kDtlsSdesFallbackSdp, CreateSessionDescription(SdpType::kOffer, kDtlsSdesFallbackSdp, nullptr));
nullptr));
EXPECT_FALSE(DoSetSessionDescription(std::move(desc), /*local=*/false)); EXPECT_FALSE(DoSetSessionDescription(std::move(desc), /*local=*/false));
} }
@ -2177,18 +2159,17 @@ TEST_P(PeerConnectionInterfaceTest, ReceiveUpdatedAudioOfferWithBadCodecs) {
CreateOfferAsLocalDescription(); CreateOfferAsLocalDescription();
const char* answer_sdp = (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED const char* answer_sdp = (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED
? webrtc::kAudioSdpPlanB ? kAudioSdpPlanB
: webrtc::kAudioSdpUnifiedPlan); : kAudioSdpUnifiedPlan);
std::unique_ptr<SessionDescriptionInterface> answer( 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)); EXPECT_TRUE(DoSetSessionDescription(std::move(answer), false));
const char* reoffer_sdp = const char* reoffer_sdp = (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED
(sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED ? kAudioSdpWithUnsupportedCodecsPlanB
? webrtc::kAudioSdpWithUnsupportedCodecsPlanB : kAudioSdpWithUnsupportedCodecsUnifiedPlan);
: webrtc::kAudioSdpWithUnsupportedCodecsUnifiedPlan);
std::unique_ptr<SessionDescriptionInterface> updated_offer( 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)); EXPECT_TRUE(DoSetSessionDescription(std::move(updated_offer), false));
CreateAnswerAsLocalDescription(); CreateAnswerAsLocalDescription();
} }
@ -2275,12 +2256,11 @@ TEST_P(PeerConnectionInterfaceTest, SetConfigurationChangesPruneTurnPortsFlag) {
config.prune_turn_ports = false; config.prune_turn_ports = false;
CreatePeerConnection(config); CreatePeerConnection(config);
config = pc_->GetConfiguration(); 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; config.prune_turn_ports = true;
EXPECT_TRUE(pc_->SetConfiguration(config).ok()); EXPECT_TRUE(pc_->SetConfiguration(config).ok());
EXPECT_EQ(webrtc::PRUNE_BASED_ON_PRIORITY, EXPECT_EQ(PRUNE_BASED_ON_PRIORITY, port_allocator_->turn_port_prune_policy());
port_allocator_->turn_port_prune_policy());
} }
// Test that the ice check interval can be changed. This does not verify that // 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; std::string sdp;
ASSERT_TRUE(pc_->remote_description()->ToString(&sdp)); ASSERT_TRUE(pc_->remote_description()->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> remote_offer( std::unique_ptr<SessionDescriptionInterface> remote_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp)); CreateSessionDescription(SdpType::kOffer, sdp));
EXPECT_FALSE(DoSetRemoteDescription(std::move(remote_offer))); EXPECT_FALSE(DoSetRemoteDescription(std::move(remote_offer)));
ASSERT_TRUE(pc_->local_description()->ToString(&sdp)); ASSERT_TRUE(pc_->local_description()->ToString(&sdp));
std::unique_ptr<SessionDescriptionInterface> local_offer( std::unique_ptr<SessionDescriptionInterface> local_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp)); CreateSessionDescription(SdpType::kOffer, sdp));
EXPECT_FALSE(DoSetLocalDescription(std::move(local_offer))); EXPECT_FALSE(DoSetLocalDescription(std::move(local_offer)));
} }
@ -2614,10 +2594,10 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
reference_collection_.get())); reference_collection_.get()));
rtc::scoped_refptr<AudioTrackInterface> audio_track2 = rtc::scoped_refptr<AudioTrackInterface> audio_track2 =
observer_.remote_streams()->at(0)->GetAudioTracks()[1]; 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 = rtc::scoped_refptr<VideoTrackInterface> video_track2 =
observer_.remote_streams()->at(0)->GetVideoTracks()[1]; 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. // Remove the extra audio and video tracks.
std::unique_ptr<SessionDescriptionInterface> desc_ms2 = std::unique_ptr<SessionDescriptionInterface> desc_ms2 =
@ -2631,10 +2611,10 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(), EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
reference_collection_.get())); reference_collection_.get()));
// Track state may be updated asynchronously. // Track state may be updated asynchronously.
EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded, EXPECT_EQ_WAIT(MediaStreamTrackInterface::kEnded, audio_track2->state(),
audio_track2->state(), kTimeout); kTimeout);
EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded, EXPECT_EQ_WAIT(MediaStreamTrackInterface::kEnded, video_track2->state(),
video_track2->state(), kTimeout); kTimeout);
} }
// This tests that remote tracks are ended if a local session description is set // 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 = rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio =
audio_receiver->track(); audio_receiver->track();
EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_audio->state()); EXPECT_EQ(MediaStreamTrackInterface::kLive, remote_audio->state());
rtc::scoped_refptr<MediaStreamTrackInterface> remote_video = rtc::scoped_refptr<MediaStreamTrackInterface> remote_video =
video_receiver->track(); video_receiver->track();
EXPECT_EQ(MediaStreamTrackInterface::kLive, remote_video->state()); EXPECT_EQ(MediaStreamTrackInterface::kLive, remote_video->state());
@ -2696,8 +2676,8 @@ TEST_F(PeerConnectionInterfaceTestPlanB, RemoveTrackThenRejectMediaContent) {
remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]); remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]);
std::unique_ptr<SessionDescriptionInterface> local_answer( std::unique_ptr<SessionDescriptionInterface> local_answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, CreateSessionDescription(SdpType::kAnswer, GetSdpStringWithStream1(),
GetSdpStringWithStream1(), nullptr)); nullptr));
cricket::ContentInfo* video_info = cricket::ContentInfo* video_info =
local_answer->description()->GetContentByName("video"); local_answer->description()->GetContentByName("video");
video_info->rejected = true; video_info->rejected = true;
@ -2986,9 +2966,9 @@ TEST_P(PeerConnectionInterfaceTest,
ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
// Grab a copy of the offer before it gets passed into the PC. // Grab a copy of the offer before it gets passed into the PC.
std::unique_ptr<SessionDescriptionInterface> modified_offer = std::unique_ptr<SessionDescriptionInterface> modified_offer =
webrtc::CreateSessionDescription( CreateSessionDescription(SdpType::kOffer, offer->session_id(),
webrtc::SdpType::kOffer, offer->session_id(), offer->session_version(),
offer->session_version(), offer->description()->Clone()); offer->description()->Clone());
EXPECT_TRUE(DoSetLocalDescription(std::move(offer))); EXPECT_TRUE(DoSetLocalDescription(std::move(offer)));
auto senders = pc_->GetSenders(); auto senders = pc_->GetSenders();
@ -3044,8 +3024,8 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0], kStreams[0])); EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0], kStreams[0]));
// Add a new MediaStream but with the same tracks as in the first stream. // Add a new MediaStream but with the same tracks as in the first stream.
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream_1( rtc::scoped_refptr<MediaStreamInterface> stream_1(
webrtc::MediaStream::Create(kStreams[1])); MediaStream::Create(kStreams[1]));
stream_1->AddTrack(stream_collection->at(0)->GetVideoTracks()[0]); stream_1->AddTrack(stream_collection->at(0)->GetVideoTracks()[0]);
stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0]); stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0]);
pc_->AddStream(stream_1.get()); pc_->AddStream(stream_1.get());
@ -3166,9 +3146,9 @@ TEST_P(PeerConnectionInterfaceTest, SetConfigurationCausingPartialIceRestart) {
EXPECT_TRUE(pc_->SetConfiguration(config).ok()); EXPECT_TRUE(pc_->SetConfiguration(config).ok());
// Do ICE restart for the first m= section, initiated by remote peer. // Do ICE restart for the first m= section, initiated by remote peer.
std::unique_ptr<webrtc::SessionDescriptionInterface> remote_offer( std::unique_ptr<SessionDescriptionInterface> remote_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, CreateSessionDescription(SdpType::kOffer, GetSdpStringWithStream1(),
GetSdpStringWithStream1(), nullptr)); nullptr));
ASSERT_TRUE(remote_offer); ASSERT_TRUE(remote_offer);
remote_offer->description()->transport_infos()[0].description.ice_ufrag = remote_offer->description()->transport_infos()[0].description.ice_ufrag =
"modified"; "modified";
@ -3214,7 +3194,7 @@ TEST_P(PeerConnectionInterfaceTest, CurrentAndPendingDescriptions) {
// Set remote pranswer. // Set remote pranswer.
std::unique_ptr<SessionDescriptionInterface> remote_pranswer( std::unique_ptr<SessionDescriptionInterface> remote_pranswer(
webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp)); CreateSessionDescription(SdpType::kPrAnswer, sdp));
SessionDescriptionInterface* remote_pranswer_ptr = remote_pranswer.get(); SessionDescriptionInterface* remote_pranswer_ptr = remote_pranswer.get();
EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_pranswer))); EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_pranswer)));
EXPECT_EQ(local_offer_ptr, pc_->pending_local_description()); EXPECT_EQ(local_offer_ptr, pc_->pending_local_description());
@ -3224,7 +3204,7 @@ TEST_P(PeerConnectionInterfaceTest, CurrentAndPendingDescriptions) {
// Set remote answer. // Set remote answer.
std::unique_ptr<SessionDescriptionInterface> remote_answer( std::unique_ptr<SessionDescriptionInterface> remote_answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, sdp)); CreateSessionDescription(SdpType::kAnswer, sdp));
SessionDescriptionInterface* remote_answer_ptr = remote_answer.get(); SessionDescriptionInterface* remote_answer_ptr = remote_answer.get();
EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_answer))); EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_answer)));
EXPECT_EQ(nullptr, pc_->pending_local_description()); EXPECT_EQ(nullptr, pc_->pending_local_description());
@ -3234,7 +3214,7 @@ TEST_P(PeerConnectionInterfaceTest, CurrentAndPendingDescriptions) {
// Set remote offer. // Set remote offer.
std::unique_ptr<SessionDescriptionInterface> remote_offer( std::unique_ptr<SessionDescriptionInterface> remote_offer(
webrtc::CreateSessionDescription(SdpType::kOffer, sdp)); CreateSessionDescription(SdpType::kOffer, sdp));
SessionDescriptionInterface* remote_offer_ptr = remote_offer.get(); SessionDescriptionInterface* remote_offer_ptr = remote_offer.get();
EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer))); EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
EXPECT_EQ(remote_offer_ptr, pc_->pending_remote_description()); EXPECT_EQ(remote_offer_ptr, pc_->pending_remote_description());
@ -3244,7 +3224,7 @@ TEST_P(PeerConnectionInterfaceTest, CurrentAndPendingDescriptions) {
// Set local pranswer. // Set local pranswer.
std::unique_ptr<SessionDescriptionInterface> local_pranswer( std::unique_ptr<SessionDescriptionInterface> local_pranswer(
webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp)); CreateSessionDescription(SdpType::kPrAnswer, sdp));
SessionDescriptionInterface* local_pranswer_ptr = local_pranswer.get(); SessionDescriptionInterface* local_pranswer_ptr = local_pranswer.get();
EXPECT_TRUE(DoSetLocalDescription(std::move(local_pranswer))); EXPECT_TRUE(DoSetLocalDescription(std::move(local_pranswer)));
EXPECT_EQ(remote_offer_ptr, pc_->pending_remote_description()); EXPECT_EQ(remote_offer_ptr, pc_->pending_remote_description());
@ -3254,7 +3234,7 @@ TEST_P(PeerConnectionInterfaceTest, CurrentAndPendingDescriptions) {
// Set local answer. // Set local answer.
std::unique_ptr<SessionDescriptionInterface> local_answer( std::unique_ptr<SessionDescriptionInterface> local_answer(
webrtc::CreateSessionDescription(SdpType::kAnswer, sdp)); CreateSessionDescription(SdpType::kAnswer, sdp));
SessionDescriptionInterface* local_answer_ptr = local_answer.get(); SessionDescriptionInterface* local_answer_ptr = local_answer.get();
EXPECT_TRUE(DoSetLocalDescription(std::move(local_answer))); EXPECT_TRUE(DoSetLocalDescription(std::move(local_answer)));
EXPECT_EQ(nullptr, pc_->pending_remote_description()); EXPECT_EQ(nullptr, pc_->pending_remote_description());
@ -3273,9 +3253,8 @@ TEST_P(PeerConnectionInterfaceTest,
// The RtcEventLog will be reset when the PeerConnection is closed. // The RtcEventLog will be reset when the PeerConnection is closed.
pc_->Close(); pc_->Close();
EXPECT_FALSE( EXPECT_FALSE(pc_->StartRtcEventLog(std::make_unique<RtcEventLogOutputNull>(),
pc_->StartRtcEventLog(std::make_unique<webrtc::RtcEventLogOutputNull>(), RtcEventLog::kImmediateOutput));
webrtc::RtcEventLog::kImmediateOutput));
pc_->StopRtcEventLog(); pc_->StopRtcEventLog();
} }

56
pc/peer_connection_media_unittest.cc
View File

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

14
pc/peer_connection_rtp_unittest.cc
View File

@ -75,13 +75,13 @@ using ::testing::UnorderedElementsAre;
using ::testing::Values; using ::testing::Values;
template <typename MethodFunctor> template <typename MethodFunctor>
class OnSuccessObserver : public webrtc::SetRemoteDescriptionObserverInterface { class OnSuccessObserver : public SetRemoteDescriptionObserverInterface {
public: public:
explicit OnSuccessObserver(MethodFunctor on_success) explicit OnSuccessObserver(MethodFunctor on_success)
: on_success_(std::move(on_success)) {} : on_success_(std::move(on_success)) {}
// webrtc::SetRemoteDescriptionObserverInterface implementation. // SetRemoteDescriptionObserverInterface implementation.
void OnSetRemoteDescriptionComplete(webrtc::RTCError error) override { void OnSetRemoteDescriptionComplete(RTCError error) override {
RTC_CHECK(error.ok()); RTC_CHECK(error.ok());
on_success_(); on_success_();
} }
@ -113,7 +113,7 @@ class PeerConnectionRtpBaseTest : public ::testing::Test {
Dav1dDecoderTemplateAdapter>>(), Dav1dDecoderTemplateAdapter>>(),
nullptr /* audio_mixer */, nullptr /* audio_mixer */,
nullptr /* audio_processing */)) { nullptr /* audio_processing */)) {
webrtc::metrics::Reset(); metrics::Reset();
} }
std::unique_ptr<PeerConnectionWrapper> CreatePeerConnection() { 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. // setting the remote description.
TEST_P(PeerConnectionRtpTest, AddTrackWithoutStreamFiresOnAddTrack) { TEST_P(PeerConnectionRtpTest, AddTrackWithoutStreamFiresOnAddTrack) {
@ -934,8 +934,8 @@ TEST_P(PeerConnectionRtpTest,
auto caller = CreatePeerConnection(); auto caller = CreatePeerConnection();
auto callee = CreatePeerConnection(); auto callee = CreatePeerConnection();
rtc::scoped_refptr<webrtc::MockSetSessionDescriptionObserver> observer = rtc::scoped_refptr<MockSetSessionDescriptionObserver> observer =
rtc::make_ref_counted<webrtc::MockSetSessionDescriptionObserver>(); rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
auto offer = caller->CreateOfferAndSetAsLocal(); auto offer = caller->CreateOfferAndSetAsLocal();
callee->pc()->SetRemoteDescription(observer.get(), offer.release()); 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" "m=bogus 9 FOO 0 8\r\n"
"c=IN IP4 0.0.0.0\r\n" "c=IN IP4 0.0.0.0\r\n"
"a=mid:bogusmid\r\n"; "a=mid:bogusmid\r\n";
std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description = std::unique_ptr<SessionDescriptionInterface> remote_description =
webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr); CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
EXPECT_TRUE(caller->SetRemoteDescription(std::move(remote_description))); 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-group:FEC-FR 1224551896 1953032773\r\n"
"a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n" "a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n"
"a=ssrc:1953032773 cname:/exJcmhSLpyu9FgV\r\n"; "a=ssrc:1953032773 cname:/exJcmhSLpyu9FgV\r\n";
std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description = std::unique_ptr<SessionDescriptionInterface> remote_description =
webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr); CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
EXPECT_TRUE(caller->SetRemoteDescription(std::move(remote_description))); 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-group:FEC-FR 1224551896 1953032773\r\n"
"a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n" "a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n"
"a=ssrc:1953032773 cname:/exJcmhSLpyu9FgV\r\n"; "a=ssrc:1953032773 cname:/exJcmhSLpyu9FgV\r\n";
std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description = std::unique_ptr<SessionDescriptionInterface> remote_description =
webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr); CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
EXPECT_TRUE(caller->SetRemoteDescription(std::move(remote_description))); 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\r\n"
"a=rtcp-fb:102 nack pli\r\n" "a=rtcp-fb:102 nack pli\r\n"
"a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n"; "a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n";
std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description = std::unique_ptr<SessionDescriptionInterface> remote_description =
webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr); CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
EXPECT_FALSE(caller->SetRemoteDescription(std::move(remote_description))); 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\r\n"
"a=rtcp-fb:102 nack pli\r\n" "a=rtcp-fb:102 nack pli\r\n"
"a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n"; "a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n";
std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description = std::unique_ptr<SessionDescriptionInterface> remote_description =
webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr); CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
EXPECT_TRUE(callee->SetRemoteDescription(std::move(remote_description))); 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 PeerConnectionSimulcastTests,
public ::testing::WithParamInterface<int> { public ::testing::WithParamInterface<int> {
protected: protected:
PeerConnectionSimulcastMetricsTests() { webrtc::metrics::Reset(); } PeerConnectionSimulcastMetricsTests() { metrics::Reset(); }
}; };
#endif #endif

77
pc/peer_connection_svc_integrationtest.cc
View File

@ -37,14 +37,13 @@ class PeerConnectionSVCIntegrationTest
: PeerConnectionIntegrationBaseTest(SdpSemantics::kUnifiedPlan) {} : PeerConnectionIntegrationBaseTest(SdpSemantics::kUnifiedPlan) {}
RTCError SetCodecPreferences( RTCError SetCodecPreferences(
rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver, rtc::scoped_refptr<RtpTransceiverInterface> transceiver,
absl::string_view codec_name) { absl::string_view codec_name) {
webrtc::RtpCapabilities capabilities = RtpCapabilities capabilities =
caller()->pc_factory()->GetRtpSenderCapabilities( caller()->pc_factory()->GetRtpSenderCapabilities(
cricket::MEDIA_TYPE_VIDEO); cricket::MEDIA_TYPE_VIDEO);
std::vector<RtpCodecCapability> codecs; std::vector<RtpCodecCapability> codecs;
for (const webrtc::RtpCodecCapability& codec_capability : for (const RtpCodecCapability& codec_capability : capabilities.codecs) {
capabilities.codecs) {
if (codec_capability.name == codec_name) if (codec_capability.name == codec_name)
codecs.push_back(codec_capability); codecs.push_back(codec_capability);
} }
@ -55,8 +54,8 @@ class PeerConnectionSVCIntegrationTest
TEST_F(PeerConnectionSVCIntegrationTest, AddTransceiverAcceptsL1T1) { TEST_F(PeerConnectionSVCIntegrationTest, AddTransceiverAcceptsL1T1) {
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
encoding_parameters.scalability_mode = "L1T1"; encoding_parameters.scalability_mode = "L1T1";
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error = auto transceiver_or_error =
@ -67,8 +66,8 @@ TEST_F(PeerConnectionSVCIntegrationTest, AddTransceiverAcceptsL1T1) {
TEST_F(PeerConnectionSVCIntegrationTest, AddTransceiverAcceptsL3T3) { TEST_F(PeerConnectionSVCIntegrationTest, AddTransceiverAcceptsL3T3) {
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
encoding_parameters.scalability_mode = "L3T3"; encoding_parameters.scalability_mode = "L3T3";
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error = auto transceiver_or_error =
@ -80,33 +79,32 @@ TEST_F(PeerConnectionSVCIntegrationTest,
AddTransceiverRejectsUnknownScalabilityMode) { AddTransceiverRejectsUnknownScalabilityMode) {
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
encoding_parameters.scalability_mode = "FOOBAR"; encoding_parameters.scalability_mode = "FOOBAR";
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error = auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init); caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
EXPECT_FALSE(transceiver_or_error.ok()); EXPECT_FALSE(transceiver_or_error.ok());
EXPECT_EQ(transceiver_or_error.error().type(), EXPECT_EQ(transceiver_or_error.error().type(),
webrtc::RTCErrorType::UNSUPPORTED_OPERATION); RTCErrorType::UNSUPPORTED_OPERATION);
} }
TEST_F(PeerConnectionSVCIntegrationTest, SetParametersAcceptsL1T3WithVP8) { TEST_F(PeerConnectionSVCIntegrationTest, SetParametersAcceptsL1T3WithVP8) {
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
webrtc::RtpCapabilities capabilities = RtpCapabilities capabilities =
caller()->pc_factory()->GetRtpSenderCapabilities( caller()->pc_factory()->GetRtpSenderCapabilities(
cricket::MEDIA_TYPE_VIDEO); cricket::MEDIA_TYPE_VIDEO);
std::vector<RtpCodecCapability> vp8_codec; std::vector<RtpCodecCapability> vp8_codec;
for (const webrtc::RtpCodecCapability& codec_capability : for (const RtpCodecCapability& codec_capability : capabilities.codecs) {
capabilities.codecs) {
if (codec_capability.name == cricket::kVp8CodecName) if (codec_capability.name == cricket::kVp8CodecName)
vp8_codec.push_back(codec_capability); vp8_codec.push_back(codec_capability);
} }
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error = auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init); caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@ -114,7 +112,7 @@ TEST_F(PeerConnectionSVCIntegrationTest, SetParametersAcceptsL1T3WithVP8) {
auto transceiver = transceiver_or_error.MoveValue(); auto transceiver = transceiver_or_error.MoveValue();
EXPECT_TRUE(transceiver->SetCodecPreferences(vp8_codec).ok()); EXPECT_TRUE(transceiver->SetCodecPreferences(vp8_codec).ok());
webrtc::RtpParameters parameters = transceiver->sender()->GetParameters(); RtpParameters parameters = transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u); ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L1T3"; parameters.encodings[0].scalability_mode = "L1T3";
auto result = transceiver->sender()->SetParameters(parameters); auto result = transceiver->sender()->SetParameters(parameters);
@ -125,8 +123,8 @@ TEST_F(PeerConnectionSVCIntegrationTest, SetParametersRejectsL3T3WithVP8) {
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error = auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init); caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@ -134,12 +132,12 @@ TEST_F(PeerConnectionSVCIntegrationTest, SetParametersRejectsL3T3WithVP8) {
auto transceiver = transceiver_or_error.MoveValue(); auto transceiver = transceiver_or_error.MoveValue();
EXPECT_TRUE(SetCodecPreferences(transceiver, cricket::kVp8CodecName).ok()); EXPECT_TRUE(SetCodecPreferences(transceiver, cricket::kVp8CodecName).ok());
webrtc::RtpParameters parameters = transceiver->sender()->GetParameters(); RtpParameters parameters = transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u); ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L3T3"; parameters.encodings[0].scalability_mode = "L3T3";
auto result = transceiver->sender()->SetParameters(parameters); auto result = transceiver->sender()->SetParameters(parameters);
EXPECT_FALSE(result.ok()); EXPECT_FALSE(result.ok());
EXPECT_EQ(result.type(), webrtc::RTCErrorType::INVALID_MODIFICATION); EXPECT_EQ(result.type(), RTCErrorType::INVALID_MODIFICATION);
} }
TEST_F(PeerConnectionSVCIntegrationTest, TEST_F(PeerConnectionSVCIntegrationTest,
@ -147,8 +145,8 @@ TEST_F(PeerConnectionSVCIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error = auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init); caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@ -159,7 +157,7 @@ TEST_F(PeerConnectionSVCIntegrationTest,
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
webrtc::RtpParameters parameters = transceiver->sender()->GetParameters(); RtpParameters parameters = transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u); ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L1T3"; parameters.encodings[0].scalability_mode = "L1T3";
auto result = transceiver->sender()->SetParameters(parameters); auto result = transceiver->sender()->SetParameters(parameters);
@ -171,8 +169,8 @@ TEST_F(PeerConnectionSVCIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error = auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init); caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@ -183,7 +181,7 @@ TEST_F(PeerConnectionSVCIntegrationTest,
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
webrtc::RtpParameters parameters = transceiver->sender()->GetParameters(); RtpParameters parameters = transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u); ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L3T3"; parameters.encodings[0].scalability_mode = "L3T3";
auto result = transceiver->sender()->SetParameters(parameters); auto result = transceiver->sender()->SetParameters(parameters);
@ -195,8 +193,8 @@ TEST_F(PeerConnectionSVCIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error = auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init); caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@ -207,12 +205,12 @@ TEST_F(PeerConnectionSVCIntegrationTest,
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
webrtc::RtpParameters parameters = transceiver->sender()->GetParameters(); RtpParameters parameters = transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u); ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L3T3"; parameters.encodings[0].scalability_mode = "L3T3";
auto result = transceiver->sender()->SetParameters(parameters); auto result = transceiver->sender()->SetParameters(parameters);
EXPECT_FALSE(result.ok()); EXPECT_FALSE(result.ok());
EXPECT_EQ(result.type(), webrtc::RTCErrorType::INVALID_MODIFICATION); EXPECT_EQ(result.type(), RTCErrorType::INVALID_MODIFICATION);
} }
TEST_F(PeerConnectionSVCIntegrationTest, TEST_F(PeerConnectionSVCIntegrationTest,
@ -220,8 +218,8 @@ TEST_F(PeerConnectionSVCIntegrationTest,
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error = auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init); caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@ -232,27 +230,27 @@ TEST_F(PeerConnectionSVCIntegrationTest,
caller()->CreateAndSetAndSignalOffer(); caller()->CreateAndSetAndSignalOffer();
ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout); ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
webrtc::RtpParameters parameters = transceiver->sender()->GetParameters(); RtpParameters parameters = transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u); ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "FOOBAR"; parameters.encodings[0].scalability_mode = "FOOBAR";
auto result = transceiver->sender()->SetParameters(parameters); auto result = transceiver->sender()->SetParameters(parameters);
EXPECT_FALSE(result.ok()); EXPECT_FALSE(result.ok());
EXPECT_EQ(result.type(), webrtc::RTCErrorType::INVALID_MODIFICATION); EXPECT_EQ(result.type(), RTCErrorType::INVALID_MODIFICATION);
} }
TEST_F(PeerConnectionSVCIntegrationTest, FallbackToL1Tx) { TEST_F(PeerConnectionSVCIntegrationTest, FallbackToL1Tx) {
ASSERT_TRUE(CreatePeerConnectionWrappers()); ASSERT_TRUE(CreatePeerConnectionWrappers());
ConnectFakeSignaling(); ConnectFakeSignaling();
webrtc::RtpTransceiverInit init; RtpTransceiverInit init;
webrtc::RtpEncodingParameters encoding_parameters; RtpEncodingParameters encoding_parameters;
init.send_encodings.push_back(encoding_parameters); init.send_encodings.push_back(encoding_parameters);
auto transceiver_or_error = auto transceiver_or_error =
caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init); caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
ASSERT_TRUE(transceiver_or_error.ok()); ASSERT_TRUE(transceiver_or_error.ok());
auto caller_transceiver = transceiver_or_error.MoveValue(); auto caller_transceiver = transceiver_or_error.MoveValue();
webrtc::RtpCapabilities capabilities = RtpCapabilities capabilities =
caller()->pc_factory()->GetRtpSenderCapabilities( caller()->pc_factory()->GetRtpSenderCapabilities(
cricket::MEDIA_TYPE_VIDEO); cricket::MEDIA_TYPE_VIDEO);
std::vector<RtpCodecCapability> send_codecs = capabilities.codecs; std::vector<RtpCodecCapability> send_codecs = capabilities.codecs;
@ -267,8 +265,7 @@ TEST_F(PeerConnectionSVCIntegrationTest, FallbackToL1Tx) {
caller_transceiver->SetCodecPreferences(send_codecs); caller_transceiver->SetCodecPreferences(send_codecs);
// L3T3 should be supported by VP9 // L3T3 should be supported by VP9
webrtc::RtpParameters parameters = RtpParameters parameters = caller_transceiver->sender()->GetParameters();
caller_transceiver->sender()->GetParameters();
ASSERT_EQ(parameters.encodings.size(), 1u); ASSERT_EQ(parameters.encodings.size(), 1u);
parameters.encodings[0].scalability_mode = "L3T3"; parameters.encodings[0].scalability_mode = "L3T3";
auto result = caller_transceiver->sender()->SetParameters(parameters); 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_; return observer()->ice_connected_;
} }
rtc::scoped_refptr<const webrtc::RTCStatsReport> rtc::scoped_refptr<const RTCStatsReport> PeerConnectionWrapper::GetStats() {
PeerConnectionWrapper::GetStats() {
auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>(); auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>();
pc()->GetStats(callback.get()); pc()->GetStats(callback.get());
EXPECT_TRUE_WAIT(callback->called(), kDefaultTimeout); 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> std::map<std::string, double>
QualityLimitationDurationToRTCQualityLimitationDuration( QualityLimitationDurationToRTCQualityLimitationDuration(
std::map<webrtc::QualityLimitationReason, int64_t> durations_ms) { std::map<QualityLimitationReason, int64_t> durations_ms) {
std::map<std::string, double> result; std::map<std::string, double> result;
// The internal duration is defined in milliseconds while the spec defines // The internal duration is defined in milliseconds while the spec defines
// the value in seconds: // the value in seconds:
@ -513,7 +513,7 @@ std::unique_ptr<RTCInboundRtpStreamStats> CreateInboundAudioStreamStats(
std::unique_ptr<RTCAudioPlayoutStats> CreateAudioPlayoutStats( std::unique_ptr<RTCAudioPlayoutStats> CreateAudioPlayoutStats(
const AudioDeviceModule::Stats& audio_device_stats, const AudioDeviceModule::Stats& audio_device_stats,
webrtc::Timestamp timestamp) { Timestamp timestamp) {
auto stats = std::make_unique<RTCAudioPlayoutStats>( auto stats = std::make_unique<RTCAudioPlayoutStats>(
/*id=*/kAudioPlayoutSingletonId, timestamp); /*id=*/kAudioPlayoutSingletonId, timestamp);
stats->synthesized_samples_duration = 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; uint32_t data_channels_closed;
// Identifies channels that have been opened, whose internal id is stored in // Identifies channels that have been opened, whose internal id is stored in
// the set until they have been fully closed. // the set until they have been fully closed.
webrtc::flat_set<int> opened_data_channels; flat_set<int> opened_data_channels;
}; };
InternalRecord internal_record_; 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 { std::string kind() const override {
return MediaStreamTrackInterface::kAudioKind; return MediaStreamTrackInterface::kAudioKind;
} }
webrtc::AudioSourceInterface* GetSource() const override { return nullptr; } AudioSourceInterface* GetSource() const override { return nullptr; }
void AddSink(webrtc::AudioTrackSinkInterface* sink) override {} void AddSink(AudioTrackSinkInterface* sink) override {}
void RemoveSink(webrtc::AudioTrackSinkInterface* sink) override {} void RemoveSink(AudioTrackSinkInterface* sink) override {}
bool GetSignalLevel(int* level) override { return false; } bool GetSignalLevel(int* level) override { return false; }
rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override { rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
return processor_; return processor_;
@ -2030,7 +2030,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidatePairStats) {
EXPECT_TRUE(report->Get(*expected_pair.transport_id)); EXPECT_TRUE(report->Get(*expected_pair.transport_id));
// Set bandwidth and "GetStats" again. // Set bandwidth and "GetStats" again.
webrtc::Call::Stats call_stats; Call::Stats call_stats;
const int kSendBandwidth = 888; const int kSendBandwidth = 888;
call_stats.send_bandwidth_bps = kSendBandwidth; call_stats.send_bandwidth_bps = kSendBandwidth;
const int kRecvBandwidth = 999; 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].key_frames_decoded = 3;
video_media_info.receivers[0].frames_dropped = 13; video_media_info.receivers[0].frames_dropped = 13;
video_media_info.receivers[0].qp_sum = absl::nullopt; video_media_info.receivers[0].qp_sum = absl::nullopt;
video_media_info.receivers[0].total_decode_time = video_media_info.receivers[0].total_decode_time = TimeDelta::Seconds(9);
webrtc::TimeDelta::Seconds(9); video_media_info.receivers[0].total_processing_delay = TimeDelta::Millis(600);
video_media_info.receivers[0].total_processing_delay = video_media_info.receivers[0].total_assembly_time = TimeDelta::Millis(500);
webrtc::TimeDelta::Millis(600);
video_media_info.receivers[0].total_assembly_time =
webrtc::TimeDelta::Millis(500);
video_media_info.receivers[0].frames_assembled_from_multiple_packets = 23; 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_inter_frame_delay = 0.123;
video_media_info.receivers[0].total_squared_inter_frame_delay = 0.00456; 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].key_frames_encoded = 3;
video_media_info.senders[0].total_encode_time_ms = 9000; 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_encoded_bytes_target = 1234;
video_media_info.senders[0].total_packet_send_delay = video_media_info.senders[0].total_packet_send_delay = TimeDelta::Seconds(10);
webrtc::TimeDelta::Seconds(10);
video_media_info.senders[0].quality_limitation_reason = video_media_info.senders[0].quality_limitation_reason =
QualityLimitationReason::kBandwidth; QualityLimitationReason::kBandwidth;
video_media_info.senders[0].quality_limitation_durations_ms video_media_info.senders[0]
[webrtc::QualityLimitationReason::kBandwidth] = 300; .quality_limitation_durations_ms[QualityLimitationReason::kBandwidth] =
300;
video_media_info.senders[0].quality_limitation_resolution_changes = 56u; video_media_info.senders[0].quality_limitation_resolution_changes = 56u;
video_media_info.senders[0].qp_sum = absl::nullopt; video_media_info.senders[0].qp_sum = absl::nullopt;
video_media_info.senders[0].content_type = VideoContentType::UNSPECIFIED; 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) { for (const RTCStats* start_node : start_nodes) {
start_ids.push_back(start_node->id()); 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) { void EXPECT_VISITED(const RTCStats* stats) {

16
pc/rtp_sender.cc
View File

@ -115,13 +115,13 @@ class SignalingThreadCallback {
if (!signaling_thread_->IsCurrent()) { if (!signaling_thread_->IsCurrent()) {
signaling_thread_->PostTask( signaling_thread_->PostTask(
[callback = std::move(callback_), error]() mutable { [callback = std::move(callback_), error]() mutable {
webrtc::InvokeSetParametersCallback(callback, error); InvokeSetParametersCallback(callback, error);
}); });
callback_ = nullptr; callback_ = nullptr;
return; return;
} }
webrtc::InvokeSetParametersCallback(callback_, error); InvokeSetParametersCallback(callback_, error);
callback_ = nullptr; callback_ = nullptr;
} }
@ -243,7 +243,7 @@ void RtpSenderBase::SetParametersInternal(const RtpParameters& parameters,
"Attempted to set an unimplemented parameter of RtpParameters."); "Attempted to set an unimplemented parameter of RtpParameters.");
RTC_LOG(LS_ERROR) << error.message() << " (" RTC_LOG(LS_ERROR) << error.message() << " ("
<< ::webrtc::ToString(error.type()) << ")"; << ::webrtc::ToString(error.type()) << ")";
webrtc::InvokeSetParametersCallback(callback, error); InvokeSetParametersCallback(callback, error);
return; return;
} }
if (!media_channel_ || !ssrc_) { if (!media_channel_ || !ssrc_) {
@ -252,7 +252,7 @@ void RtpSenderBase::SetParametersInternal(const RtpParameters& parameters,
if (result.ok()) { if (result.ok()) {
init_parameters_ = parameters; init_parameters_ = parameters;
} }
webrtc::InvokeSetParametersCallback(callback, result); InvokeSetParametersCallback(callback, result);
return; return;
} }
auto task = [&, callback = std::move(callback), auto task = [&, callback = std::move(callback),
@ -268,13 +268,13 @@ void RtpSenderBase::SetParametersInternal(const RtpParameters& parameters,
RTCError result = cricket::CheckRtpParametersInvalidModificationAndValues( RTCError result = cricket::CheckRtpParametersInvalidModificationAndValues(
old_parameters, rtp_parameters); old_parameters, rtp_parameters);
if (!result.ok()) { if (!result.ok()) {
webrtc::InvokeSetParametersCallback(callback, result); InvokeSetParametersCallback(callback, result);
return; return;
} }
result = CheckCodecParameters(rtp_parameters); result = CheckCodecParameters(rtp_parameters);
if (!result.ok()) { if (!result.ok()) {
webrtc::InvokeSetParametersCallback(callback, result); InvokeSetParametersCallback(callback, result);
return; return;
} }
@ -389,7 +389,7 @@ void RtpSenderBase::SetParametersAsync(const RtpParameters& parameters,
TRACE_EVENT0("webrtc", "RtpSenderBase::SetParametersAsync"); TRACE_EVENT0("webrtc", "RtpSenderBase::SetParametersAsync");
RTCError result = CheckSetParameters(parameters); RTCError result = CheckSetParameters(parameters);
if (!result.ok()) { if (!result.ok()) {
webrtc::InvokeSetParametersCallback(callback, result); InvokeSetParametersCallback(callback, result);
return; return;
} }
@ -399,7 +399,7 @@ void RtpSenderBase::SetParametersAsync(const RtpParameters& parameters,
signaling_thread_, signaling_thread_,
[this, callback = std::move(callback)](RTCError error) mutable { [this, callback = std::move(callback)](RTCError error) mutable {
last_transaction_id_.reset(); last_transaction_id_.reset();
webrtc::InvokeSetParametersCallback(callback, error); InvokeSetParametersCallback(callback, error);
}), }),
false); 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 // Additional checks that are specific to the current codec settings
virtual RTCError CheckCodecParameters(const RtpParameters& parameters) { virtual RTCError CheckCodecParameters(const RtpParameters& parameters) {
return webrtc::RTCError::OK(); return RTCError::OK();
} }
// Returns an ID that changes every time SetTrack() is called, but // 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()), : network_thread_(rtc::Thread::Current()),
worker_thread_(rtc::Thread::Current()), worker_thread_(rtc::Thread::Current()),
video_bitrate_allocator_factory_( video_bitrate_allocator_factory_(
webrtc::CreateBuiltinVideoBitrateAllocatorFactory()), CreateBuiltinVideoBitrateAllocatorFactory()),
// Create fake media engine/etc. so we can create channels to use to // Create fake media engine/etc. so we can create channels to use to
// test RtpSenders/RtpReceivers. // test RtpSenders/RtpReceivers.
media_engine_(std::make_unique<cricket::FakeMediaEngine>()), media_engine_(std::make_unique<cricket::FakeMediaEngine>()),
@ -119,16 +119,16 @@ class RtpSenderReceiverTest
// Fake media channels are owned by the media engine. // Fake media channels are owned by the media engine.
voice_media_send_channel_ = media_engine_->voice().CreateSendChannel( voice_media_send_channel_ = media_engine_->voice().CreateSendChannel(
&fake_call_, cricket::MediaConfig(), cricket::AudioOptions(), &fake_call_, cricket::MediaConfig(), cricket::AudioOptions(),
webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); CryptoOptions(), AudioCodecPairId::Create());
video_media_send_channel_ = media_engine_->video().CreateSendChannel( video_media_send_channel_ = media_engine_->video().CreateSendChannel(
&fake_call_, cricket::MediaConfig(), cricket::VideoOptions(), &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( voice_media_receive_channel_ = media_engine_->voice().CreateReceiveChannel(
&fake_call_, cricket::MediaConfig(), cricket::AudioOptions(), &fake_call_, cricket::MediaConfig(), cricket::AudioOptions(),
webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); CryptoOptions(), AudioCodecPairId::Create());
video_media_receive_channel_ = media_engine_->video().CreateReceiveChannel( video_media_receive_channel_ = media_engine_->video().CreateReceiveChannel(
&fake_call_, cricket::MediaConfig(), cricket::VideoOptions(), &fake_call_, cricket::MediaConfig(), cricket::VideoOptions(),
webrtc::CryptoOptions()); CryptoOptions());
// Create streams for predefined SSRCs. Streams need to exist in order // Create streams for predefined SSRCs. Streams need to exist in order
// for the senders and receievers to apply parameters to them. // for the senders and receievers to apply parameters to them.
@ -162,8 +162,8 @@ class RtpSenderReceiverTest
audio_track_ = nullptr; audio_track_ = nullptr;
} }
std::unique_ptr<webrtc::RtpTransportInternal> CreateDtlsSrtpTransport() { std::unique_ptr<RtpTransportInternal> CreateDtlsSrtpTransport() {
auto dtls_srtp_transport = std::make_unique<webrtc::DtlsSrtpTransport>( auto dtls_srtp_transport = std::make_unique<DtlsSrtpTransport>(
/*rtcp_mux_required=*/true, field_trials_); /*rtcp_mux_required=*/true, field_trials_);
dtls_srtp_transport->SetDtlsTransports(rtp_dtls_transport_.get(), dtls_srtp_transport->SetDtlsTransports(rtp_dtls_transport_.get(),
/*rtcp_dtls_transport=*/nullptr); /*rtcp_dtls_transport=*/nullptr);
@ -515,12 +515,12 @@ class RtpSenderReceiverTest
test::RunLoop run_loop_; test::RunLoop run_loop_;
rtc::Thread* const network_thread_; rtc::Thread* const network_thread_;
rtc::Thread* const worker_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 `rtp_dtls_transport_` and `rtp_transport_` should be destroyed after
// the `channel_manager`. // the `channel_manager`.
std::unique_ptr<cricket::DtlsTransportInternal> rtp_dtls_transport_; std::unique_ptr<cricket::DtlsTransportInternal> rtp_dtls_transport_;
std::unique_ptr<webrtc::RtpTransportInternal> rtp_transport_; std::unique_ptr<RtpTransportInternal> rtp_transport_;
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory> std::unique_ptr<VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory_; video_bitrate_allocator_factory_;
std::unique_ptr<cricket::FakeMediaEngine> media_engine_; std::unique_ptr<cricket::FakeMediaEngine> media_engine_;
rtc::UniqueRandomIdGenerator ssrc_generator_; rtc::UniqueRandomIdGenerator ssrc_generator_;
@ -540,7 +540,7 @@ class RtpSenderReceiverTest
rtc::scoped_refptr<MediaStreamInterface> local_stream_; rtc::scoped_refptr<MediaStreamInterface> local_stream_;
rtc::scoped_refptr<VideoTrackInterface> video_track_; rtc::scoped_refptr<VideoTrackInterface> video_track_;
rtc::scoped_refptr<AudioTrackInterface> audio_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 // Test that `voice_channel_` is updated when an audio track is associated
@ -651,15 +651,13 @@ TEST_F(RtpSenderReceiverTest, LocalVideoTrackDisable) {
TEST_F(RtpSenderReceiverTest, RemoteVideoTrackState) { TEST_F(RtpSenderReceiverTest, RemoteVideoTrackState) {
CreateVideoRtpReceiver(); CreateVideoRtpReceiver();
EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, video_track_->state()); EXPECT_EQ(MediaStreamTrackInterface::kLive, video_track_->state());
EXPECT_EQ(webrtc::MediaSourceInterface::kLive, EXPECT_EQ(MediaSourceInterface::kLive, video_track_->GetSource()->state());
video_track_->GetSource()->state());
DestroyVideoRtpReceiver(); DestroyVideoRtpReceiver();
EXPECT_EQ(webrtc::MediaStreamTrackInterface::kEnded, video_track_->state()); EXPECT_EQ(MediaStreamTrackInterface::kEnded, video_track_->state());
EXPECT_EQ(webrtc::MediaSourceInterface::kEnded, EXPECT_EQ(MediaSourceInterface::kEnded, video_track_->GetSource()->state());
video_track_->GetSource()->state());
DestroyVideoRtpReceiver(); DestroyVideoRtpReceiver();
} }
@ -888,9 +886,9 @@ TEST_F(RtpSenderReceiverTest, AudioSenderCanSetParametersAsync) {
RtpParameters params = audio_rtp_sender_->GetParameters(); RtpParameters params = audio_rtp_sender_->GetParameters();
EXPECT_EQ(1u, params.encodings.size()); EXPECT_EQ(1u, params.encodings.size());
absl::optional<webrtc::RTCError> result; absl::optional<RTCError> result;
audio_rtp_sender_->SetParametersAsync( audio_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; }); params, [&result](RTCError error) { result = error; });
run_loop_.Flush(); run_loop_.Flush();
EXPECT_TRUE(result->ok()); EXPECT_TRUE(result->ok());
@ -918,13 +916,13 @@ TEST_F(RtpSenderReceiverTest,
audio_rtp_sender_ = audio_rtp_sender_ =
AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr, nullptr); AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr, nullptr);
absl::optional<webrtc::RTCError> result; absl::optional<RTCError> result;
RtpParameters params = audio_rtp_sender_->GetParameters(); RtpParameters params = audio_rtp_sender_->GetParameters();
ASSERT_EQ(1u, params.encodings.size()); ASSERT_EQ(1u, params.encodings.size());
params.encodings[0].max_bitrate_bps = 90000; params.encodings[0].max_bitrate_bps = 90000;
audio_rtp_sender_->SetParametersAsync( audio_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; }); params, [&result](RTCError error) { result = error; });
run_loop_.Flush(); run_loop_.Flush();
EXPECT_TRUE(result->ok()); EXPECT_TRUE(result->ok());
@ -932,7 +930,7 @@ TEST_F(RtpSenderReceiverTest,
EXPECT_EQ(params.encodings[0].max_bitrate_bps, 90000); EXPECT_EQ(params.encodings[0].max_bitrate_bps, 90000);
audio_rtp_sender_->SetParametersAsync( audio_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; }); params, [&result](RTCError error) { result = error; });
run_loop_.Flush(); run_loop_.Flush();
EXPECT_TRUE(result->ok()); EXPECT_TRUE(result->ok());
@ -1016,13 +1014,13 @@ TEST_F(RtpSenderReceiverTest,
RtpParameters params = audio_rtp_sender_->GetParameters(); RtpParameters params = audio_rtp_sender_->GetParameters();
EXPECT_EQ(1u, params.encodings.size()); EXPECT_EQ(1u, params.encodings.size());
absl::optional<webrtc::RTCError> result; absl::optional<RTCError> result;
audio_rtp_sender_->SetParametersAsync( audio_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; }); params, [&result](RTCError error) { result = error; });
run_loop_.Flush(); run_loop_.Flush();
EXPECT_TRUE(result->ok()); EXPECT_TRUE(result->ok());
audio_rtp_sender_->SetParametersAsync( audio_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; }); params, [&result](RTCError error) { result = error; });
run_loop_.Flush(); run_loop_.Flush();
EXPECT_EQ(RTCErrorType::INVALID_STATE, result->type()); EXPECT_EQ(RTCErrorType::INVALID_STATE, result->type());
@ -1081,7 +1079,7 @@ TEST_F(RtpSenderReceiverTest, SetAudioMaxSendBitrate) {
CreateAudioRtpSender(); CreateAudioRtpSender();
EXPECT_EQ(-1, voice_media_send_channel()->max_bps()); 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_EQ(1U, params.encodings.size());
EXPECT_FALSE(params.encodings[0].max_bitrate_bps); EXPECT_FALSE(params.encodings[0].max_bitrate_bps);
params.encodings[0].max_bitrate_bps = 1000; params.encodings[0].max_bitrate_bps = 1000;
@ -1106,10 +1104,9 @@ TEST_F(RtpSenderReceiverTest, SetAudioMaxSendBitrate) {
TEST_F(RtpSenderReceiverTest, SetAudioBitratePriority) { TEST_F(RtpSenderReceiverTest, SetAudioBitratePriority) {
CreateAudioRtpSender(); CreateAudioRtpSender();
webrtc::RtpParameters params = audio_rtp_sender_->GetParameters(); RtpParameters params = audio_rtp_sender_->GetParameters();
EXPECT_EQ(1U, params.encodings.size()); EXPECT_EQ(1U, params.encodings.size());
EXPECT_EQ(webrtc::kDefaultBitratePriority, EXPECT_EQ(kDefaultBitratePriority, params.encodings[0].bitrate_priority);
params.encodings[0].bitrate_priority);
double new_bitrate_priority = 2.0; double new_bitrate_priority = 2.0;
params.encodings[0].bitrate_priority = new_bitrate_priority; params.encodings[0].bitrate_priority = new_bitrate_priority;
EXPECT_TRUE(audio_rtp_sender_->SetParameters(params).ok()); EXPECT_TRUE(audio_rtp_sender_->SetParameters(params).ok());
@ -1140,9 +1137,9 @@ TEST_F(RtpSenderReceiverTest, VideoSenderCanSetParametersAsync) {
RtpParameters params = video_rtp_sender_->GetParameters(); RtpParameters params = video_rtp_sender_->GetParameters();
EXPECT_EQ(1u, params.encodings.size()); EXPECT_EQ(1u, params.encodings.size());
absl::optional<webrtc::RTCError> result; absl::optional<RTCError> result;
video_rtp_sender_->SetParametersAsync( video_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; }); params, [&result](RTCError error) { result = error; });
run_loop_.Flush(); run_loop_.Flush();
EXPECT_TRUE(result->ok()); EXPECT_TRUE(result->ok());
@ -1170,19 +1167,19 @@ TEST_F(RtpSenderReceiverTest,
video_rtp_sender_ = video_rtp_sender_ =
VideoRtpSender::Create(worker_thread_, /*id=*/"", nullptr); VideoRtpSender::Create(worker_thread_, /*id=*/"", nullptr);
absl::optional<webrtc::RTCError> result; absl::optional<RTCError> result;
RtpParameters params = video_rtp_sender_->GetParameters(); RtpParameters params = video_rtp_sender_->GetParameters();
ASSERT_EQ(1u, params.encodings.size()); ASSERT_EQ(1u, params.encodings.size());
params.encodings[0].max_bitrate_bps = 90000; params.encodings[0].max_bitrate_bps = 90000;
video_rtp_sender_->SetParametersAsync( video_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; }); params, [&result](RTCError error) { result = error; });
run_loop_.Flush(); run_loop_.Flush();
EXPECT_TRUE(result->ok()); EXPECT_TRUE(result->ok());
params = video_rtp_sender_->GetParameters(); params = video_rtp_sender_->GetParameters();
EXPECT_EQ(params.encodings[0].max_bitrate_bps, 90000); EXPECT_EQ(params.encodings[0].max_bitrate_bps, 90000);
video_rtp_sender_->SetParametersAsync( video_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; }); params, [&result](RTCError error) { result = error; });
run_loop_.Flush(); run_loop_.Flush();
EXPECT_TRUE(result->ok()); EXPECT_TRUE(result->ok());
@ -1350,13 +1347,13 @@ TEST_F(RtpSenderReceiverTest,
RtpParameters params = video_rtp_sender_->GetParameters(); RtpParameters params = video_rtp_sender_->GetParameters();
EXPECT_EQ(1u, params.encodings.size()); EXPECT_EQ(1u, params.encodings.size());
absl::optional<webrtc::RTCError> result; absl::optional<RTCError> result;
video_rtp_sender_->SetParametersAsync( video_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; }); params, [&result](RTCError error) { result = error; });
run_loop_.Flush(); run_loop_.Flush();
EXPECT_TRUE(result->ok()); EXPECT_TRUE(result->ok());
video_rtp_sender_->SetParametersAsync( video_rtp_sender_->SetParametersAsync(
params, [&result](webrtc::RTCError error) { result = error; }); params, [&result](RTCError error) { result = error; });
run_loop_.Flush(); run_loop_.Flush();
EXPECT_EQ(RTCErrorType::INVALID_STATE, result->type()); EXPECT_EQ(RTCErrorType::INVALID_STATE, result->type());
@ -1453,7 +1450,7 @@ TEST_F(RtpSenderReceiverTest, VideoSenderDetectInvalidNumTemporalLayers) {
CreateVideoRtpSender(); CreateVideoRtpSender();
RtpParameters params = video_rtp_sender_->GetParameters(); 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); RTCError result = video_rtp_sender_->SetParameters(params);
EXPECT_EQ(RTCErrorType::INVALID_RANGE, result.type()); EXPECT_EQ(RTCErrorType::INVALID_RANGE, result.type());
@ -1536,7 +1533,7 @@ TEST_F(RtpSenderReceiverTest, SetVideoMinMaxSendBitrate) {
CreateVideoRtpSender(); CreateVideoRtpSender();
EXPECT_EQ(-1, video_media_send_channel()->max_bps()); 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_EQ(1U, params.encodings.size());
EXPECT_FALSE(params.encodings[0].min_bitrate_bps); EXPECT_FALSE(params.encodings[0].min_bitrate_bps);
EXPECT_FALSE(params.encodings[0].max_bitrate_bps); EXPECT_FALSE(params.encodings[0].max_bitrate_bps);
@ -1589,10 +1586,9 @@ TEST_F(RtpSenderReceiverTest, SetVideoMinMaxSendBitrateSimulcast) {
TEST_F(RtpSenderReceiverTest, SetVideoBitratePriority) { TEST_F(RtpSenderReceiverTest, SetVideoBitratePriority) {
CreateVideoRtpSender(); CreateVideoRtpSender();
webrtc::RtpParameters params = video_rtp_sender_->GetParameters(); RtpParameters params = video_rtp_sender_->GetParameters();
EXPECT_EQ(1U, params.encodings.size()); EXPECT_EQ(1U, params.encodings.size());
EXPECT_EQ(webrtc::kDefaultBitratePriority, EXPECT_EQ(kDefaultBitratePriority, params.encodings[0].bitrate_priority);
params.encodings[0].bitrate_priority);
double new_bitrate_priority = 2.0; double new_bitrate_priority = 2.0;
params.encodings[0].bitrate_priority = new_bitrate_priority; params.encodings[0].bitrate_priority = new_bitrate_priority;
EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok()); 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 { RtpTransceiverDirection RtpTransceiver::direction() const {
if (unified_plan_ && stopping()) if (unified_plan_ && stopping())
return webrtc::RtpTransceiverDirection::kStopped; return RtpTransceiverDirection::kStopped;
return direction_; return direction_;
} }
@ -570,7 +570,7 @@ RTCError RtpTransceiver::SetDirectionWithError(
absl::optional<RtpTransceiverDirection> RtpTransceiver::current_direction() absl::optional<RtpTransceiverDirection> RtpTransceiver::current_direction()
const { const {
if (unified_plan_ && stopped()) if (unified_plan_ && stopped())
return webrtc::RtpTransceiverDirection::kStopped; return RtpTransceiverDirection::kStopped;
return current_direction_; return current_direction_;
} }
@ -604,7 +604,7 @@ void RtpTransceiver::StopSendingAndReceiving() {
}); });
stopping_ = true; stopping_ = true;
direction_ = webrtc::RtpTransceiverDirection::kInactive; direction_ = RtpTransceiverDirection::kInactive;
} }
RTCError RtpTransceiver::StopStandard() { 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, stopped)
PROXY_CONSTMETHOD0(bool, stopping) PROXY_CONSTMETHOD0(bool, stopping)
PROXY_CONSTMETHOD0(RtpTransceiverDirection, direction) 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>, current_direction)
PROXY_CONSTMETHOD0(absl::optional<RtpTransceiverDirection>, fired_direction) PROXY_CONSTMETHOD0(absl::optional<RtpTransceiverDirection>, fired_direction)
PROXY_METHOD0(webrtc::RTCError, StopStandard) PROXY_METHOD0(RTCError, StopStandard)
PROXY_METHOD0(void, StopInternal) PROXY_METHOD0(void, StopInternal)
PROXY_METHOD1(webrtc::RTCError, PROXY_METHOD1(RTCError, SetCodecPreferences, rtc::ArrayView<RtpCodecCapability>)
SetCodecPreferences,
rtc::ArrayView<RtpCodecCapability>)
PROXY_CONSTMETHOD0(std::vector<RtpCodecCapability>, codec_preferences) PROXY_CONSTMETHOD0(std::vector<RtpCodecCapability>, codec_preferences)
PROXY_CONSTMETHOD0(std::vector<RtpHeaderExtensionCapability>, PROXY_CONSTMETHOD0(std::vector<RtpHeaderExtensionCapability>,
GetHeaderExtensionsToNegotiate) GetHeaderExtensionsToNegotiate)
PROXY_CONSTMETHOD0(std::vector<RtpHeaderExtensionCapability>, PROXY_CONSTMETHOD0(std::vector<RtpHeaderExtensionCapability>,
GetNegotiatedHeaderExtensions) GetNegotiatedHeaderExtensions)
PROXY_METHOD1(webrtc::RTCError, PROXY_METHOD1(RTCError,
SetHeaderExtensionsToNegotiate, SetHeaderExtensionsToNegotiate,
rtc::ArrayView<const RtpHeaderExtensionCapability>) rtc::ArrayView<const RtpHeaderExtensionCapability>)
END_PROXY_MAP(RtpTransceiver) 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, mid()).WillRepeatedly(ReturnRef(content_name));
EXPECT_CALL(*mock_channel, SetRtpTransport(_)).WillRepeatedly(Return(true)); EXPECT_CALL(*mock_channel, SetRtpTransport(_)).WillRepeatedly(Return(true));
cricket::RtpHeaderExtensions extensions = {webrtc::RtpExtension("uri1", 1), cricket::RtpHeaderExtensions extensions = {RtpExtension("uri1", 1),
webrtc::RtpExtension("uri2", 2)}; RtpExtension("uri2", 2)};
cricket::AudioContentDescription description; cricket::AudioContentDescription description;
description.set_rtp_header_extensions(extensions); description.set_rtp_header_extensions(extensions);
transceiver_->OnNegotiationUpdate(SdpType::kAnswer, &description); transceiver_->OnNegotiationUpdate(SdpType::kAnswer, &description);
@ -449,8 +449,8 @@ TEST_F(RtpTransceiverTestForHeaderExtensions,
EXPECT_CALL(*sender_.get(), SetTransceiverAsStopped()); EXPECT_CALL(*sender_.get(), SetTransceiverAsStopped());
EXPECT_CALL(*sender_.get(), Stop()); EXPECT_CALL(*sender_.get(), Stop());
cricket::RtpHeaderExtensions extensions = {webrtc::RtpExtension("uri1", 1), cricket::RtpHeaderExtensions extensions = {RtpExtension("uri1", 1),
webrtc::RtpExtension("uri2", 2)}; RtpExtension("uri2", 2)};
cricket::AudioContentDescription description; cricket::AudioContentDescription description;
description.set_rtp_header_extensions(extensions); description.set_rtp_header_extensions(extensions);
transceiver_->OnNegotiationUpdate(SdpType::kAnswer, &description); transceiver_->OnNegotiationUpdate(SdpType::kAnswer, &description);
@ -464,8 +464,7 @@ TEST_F(RtpTransceiverTestForHeaderExtensions,
RtpTransceiverDirection::kStopped), RtpTransceiverDirection::kStopped),
Field(&RtpHeaderExtensionCapability::direction, Field(&RtpHeaderExtensionCapability::direction,
RtpTransceiverDirection::kStopped))); RtpTransceiverDirection::kStopped)));
extensions = {webrtc::RtpExtension("uri3", 4), extensions = {RtpExtension("uri3", 4), RtpExtension("uri5", 6)};
webrtc::RtpExtension("uri5", 6)};
description.set_rtp_header_extensions(extensions); description.set_rtp_header_extensions(extensions);
transceiver_->OnNegotiationUpdate(SdpType::kAnswer, &description); transceiver_->OnNegotiationUpdate(SdpType::kAnswer, &description);

4
pc/rtp_transport.cc
View File

@ -186,8 +186,8 @@ flat_set<uint32_t> RtpTransport::GetSsrcsForSink(RtpPacketSinkInterface* sink) {
void RtpTransport::DemuxPacket(rtc::CopyOnWriteBuffer packet, void RtpTransport::DemuxPacket(rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us) { int64_t packet_time_us) {
webrtc::RtpPacketReceived parsed_packet( RtpPacketReceived parsed_packet(&header_extension_map_,
&header_extension_map_, packet_time_us == -1 packet_time_us == -1
? Timestamp::MinusInfinity() ? Timestamp::MinusInfinity()
: Timestamp::Micros(packet_time_us)); : Timestamp::Micros(packet_time_us));
if (!parsed_packet.Parse(std::move(packet))) { if (!parsed_packet.Parse(std::move(packet))) {

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 // Called whenever a RTP packet that can not be demuxed by the transport is
// received. // received.
void SetUnDemuxableRtpPacketReceivedHandler( void SetUnDemuxableRtpPacketReceivedHandler(
absl::AnyInvocable<void(webrtc::RtpPacketReceived&)> callback) { absl::AnyInvocable<void(RtpPacketReceived&)> callback) {
callback_undemuxable_rtp_packet_received_ = std::move(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<bool> callback_list_ready_to_send_;
CallbackList<rtc::CopyOnWriteBuffer*, int64_t> CallbackList<rtc::CopyOnWriteBuffer*, int64_t>
callback_list_rtcp_packet_received_; callback_list_rtcp_packet_received_;
absl::AnyInvocable<void(webrtc::RtpPacketReceived&)> absl::AnyInvocable<void(RtpPacketReceived&)>
callback_undemuxable_rtp_packet_received_ = callback_undemuxable_rtp_packet_received_ =
[](RtpPacketReceived& packet) {}; [](RtpPacketReceived& packet) {};
CallbackList<absl::optional<rtc::NetworkRoute>> 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); void Start(int local_port, int remote_port, int max_message_size);
// TODO(https://bugs.webrtc.org/10629): Move functions that need // 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. // and make the internal() function private.
cricket::SctpTransportInternal* internal() { cricket::SctpTransportInternal* internal() {
RTC_DCHECK_RUN_ON(owner_thread_); RTC_DCHECK_RUN_ON(owner_thread_);

9
pc/sdp_offer_answer.cc
View File

@ -86,8 +86,7 @@ namespace webrtc {
namespace { namespace {
typedef webrtc::PeerConnectionInterface::RTCOfferAnswerOptions typedef PeerConnectionInterface::RTCOfferAnswerOptions RTCOfferAnswerOptions;
RTCOfferAnswerOptions;
// Error messages // Error messages
const char kInvalidSdp[] = "Invalid session description."; const char kInvalidSdp[] = "Invalid session description.";
@ -834,8 +833,8 @@ std::string GenerateRtcpCname() {
} }
// Check if we can send `new_stream` on a PeerConnection. // Check if we can send `new_stream` on a PeerConnection.
bool CanAddLocalMediaStream(webrtc::StreamCollectionInterface* current_streams, bool CanAddLocalMediaStream(StreamCollectionInterface* current_streams,
webrtc::MediaStreamInterface* new_stream) { MediaStreamInterface* new_stream) {
if (!new_stream || !current_streams) { if (!new_stream || !current_streams) {
return false; return false;
} }
@ -847,7 +846,7 @@ bool CanAddLocalMediaStream(webrtc::StreamCollectionInterface* current_streams,
return true; return true;
} }
rtc::scoped_refptr<webrtc::DtlsTransport> LookupDtlsTransportByMid( rtc::scoped_refptr<DtlsTransport> LookupDtlsTransportByMid(
rtc::Thread* network_thread, rtc::Thread* network_thread,
JsepTransportController* controller, JsepTransportController* controller,
const std::string& mid) { 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. // or else the CreateBuiltinVideoBitrateAllocatorFactory() will be called.
// Note that one can still choose to override this in a MediaEngine // Note that one can still choose to override this in a MediaEngine
// if one wants too. // if one wants too.
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory> std::unique_ptr<VideoBitrateAllocatorFactory> video_bitrate_allocator_factory_
video_bitrate_allocator_factory_ RTC_GUARDED_BY(signaling_thread()); RTC_GUARDED_BY(signaling_thread());
// Whether we are the initial offerer on the association. This // Whether we are the initial offerer on the association. This
// determines the SSL role. // determines the SSL role.

20
pc/sdp_offer_answer_unittest.cc
View File

@ -88,7 +88,7 @@ class SdpOfferAnswerTest : public ::testing::Test {
Dav1dDecoderTemplateAdapter>>(), Dav1dDecoderTemplateAdapter>>(),
nullptr /* audio_mixer */, nullptr /* audio_mixer */,
nullptr /* audio_processing */)) { nullptr /* audio_processing */)) {
webrtc::metrics::Reset(); metrics::Reset();
} }
std::unique_ptr<PeerConnectionWrapper> CreatePeerConnection() { std::unique_ptr<PeerConnectionWrapper> CreatePeerConnection() {
@ -168,8 +168,8 @@ TEST_F(SdpOfferAnswerTest, BundleRejectsCodecCollisionsAudioVideo) {
// There is no error yet but the metrics counter will increase. // There is no error yet but the metrics counter will increase.
EXPECT_TRUE(error.ok()); EXPECT_TRUE(error.ok());
EXPECT_METRIC_EQ( EXPECT_METRIC_EQ(
1, webrtc::metrics::NumEvents( 1, metrics::NumEvents("WebRTC.PeerConnection.ValidBundledPayloadTypes",
"WebRTC.PeerConnection.ValidBundledPayloadTypes", false)); false));
// Tolerate codec collisions in rejected m-lines. // Tolerate codec collisions in rejected m-lines.
pc = CreatePeerConnection(); pc = CreatePeerConnection();
@ -178,9 +178,9 @@ TEST_F(SdpOfferAnswerTest, BundleRejectsCodecCollisionsAudioVideo) {
absl::StrReplaceAll(sdp, {{"m=video 9 ", "m=video 0 "}})); absl::StrReplaceAll(sdp, {{"m=video 9 ", "m=video 0 "}}));
pc->SetRemoteDescription(std::move(rejected_offer), &error); pc->SetRemoteDescription(std::move(rejected_offer), &error);
EXPECT_TRUE(error.ok()); EXPECT_TRUE(error.ok());
EXPECT_METRIC_EQ(1, EXPECT_METRIC_EQ(
webrtc::metrics::NumEvents( 1, metrics::NumEvents("WebRTC.PeerConnection.ValidBundledPayloadTypes",
"WebRTC.PeerConnection.ValidBundledPayloadTypes", true)); true));
} }
TEST_F(SdpOfferAnswerTest, BundleRejectsCodecCollisionsVideoFmtp) { TEST_F(SdpOfferAnswerTest, BundleRejectsCodecCollisionsVideoFmtp) {
@ -221,8 +221,8 @@ TEST_F(SdpOfferAnswerTest, BundleRejectsCodecCollisionsVideoFmtp) {
pc->SetRemoteDescription(std::move(desc), &error); pc->SetRemoteDescription(std::move(desc), &error);
EXPECT_TRUE(error.ok()); EXPECT_TRUE(error.ok());
EXPECT_METRIC_EQ( EXPECT_METRIC_EQ(
1, webrtc::metrics::NumEvents( 1, metrics::NumEvents("WebRTC.PeerConnection.ValidBundledPayloadTypes",
"WebRTC.PeerConnection.ValidBundledPayloadTypes", false)); false));
} }
TEST_F(SdpOfferAnswerTest, BundleCodecCollisionInDifferentBundlesAllowed) { TEST_F(SdpOfferAnswerTest, BundleCodecCollisionInDifferentBundlesAllowed) {
@ -264,8 +264,8 @@ TEST_F(SdpOfferAnswerTest, BundleCodecCollisionInDifferentBundlesAllowed) {
pc->SetRemoteDescription(std::move(desc), &error); pc->SetRemoteDescription(std::move(desc), &error);
EXPECT_TRUE(error.ok()); EXPECT_TRUE(error.ok());
EXPECT_METRIC_EQ( EXPECT_METRIC_EQ(
0, webrtc::metrics::NumEvents( 0, metrics::NumEvents("WebRTC.PeerConnection.ValidBundledPayloadTypes",
"WebRTC.PeerConnection.ValidBundledPayloadTypes", false)); false));
} }
TEST_F(SdpOfferAnswerTest, BundleMeasuresHeaderExtensionIdCollision) { 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 // Some things use a time of "0" as a special value, so we need to start out
// the fake clock at a nonzero time. // the fake clock at a nonzero time.
// TODO(deadbeef): Fix this. // TODO(deadbeef): Fix this.
AdvanceTime(webrtc::TimeDelta::Seconds(1000)); AdvanceTime(TimeDelta::Seconds(1000));
} }
// Explicit handle. // Explicit handle.
@ -170,20 +170,20 @@ TEST_P(PeerConnectionIntegrationTest,
CreateTurnServer(turn_server_internal_address, turn_server_external_address, CreateTurnServer(turn_server_internal_address, turn_server_external_address,
cricket::PROTO_TLS, "88.88.88.0"); 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.urls.push_back("turns:88.88.88.0:3478?transport=tcp");
ice_server.username = "test"; ice_server.username = "test";
ice_server.password = "test"; ice_server.password = "test";
PeerConnectionInterface::RTCConfiguration client_1_config; PeerConnectionInterface::RTCConfiguration client_1_config;
client_1_config.servers.push_back(ice_server); 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; PeerConnectionInterface::RTCConfiguration client_2_config;
client_2_config.servers.push_back(ice_server); client_2_config.servers.push_back(ice_server);
// Setting the type to kRelay forces the connection to go through a TURN // Setting the type to kRelay forces the connection to go through a TURN
// server. // 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. // Get a copy to the pointer so we can verify calls later.
rtc::TestCertificateVerifier* client_1_cert_verifier = rtc::TestCertificateVerifier* client_1_cert_verifier =
@ -194,10 +194,10 @@ TEST_P(PeerConnectionIntegrationTest,
client_2_cert_verifier->verify_certificate_ = false; client_2_cert_verifier->verify_certificate_ = false;
// Create the dependencies with the test certificate verifier. // 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 = client_1_deps.tls_cert_verifier =
std::unique_ptr<rtc::TestCertificateVerifier>(client_1_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 = client_2_deps.tls_cert_verifier =
std::unique_ptr<rtc::TestCertificateVerifier>(client_2_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_; TransportObserver rtp_sink2_;
int sequence_number_ = 0; int sequence_number_ = 0;
webrtc::test::ScopedKeyValueConfig field_trials_; test::ScopedKeyValueConfig field_trials_;
}; };
class SrtpTransportTestWithExternalAuth class SrtpTransportTestWithExternalAuth

2
pc/test/android_test_initializer.cc
View File

@ -39,7 +39,7 @@ void EnsureInitializedOnce() {
RTC_CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()"; RTC_CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()";
webrtc::JVM::Initialize(jvm); JVM::Initialize(jvm);
} }
} // anonymous namespace } // 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_; } const FieldTrialsView& trials() const override { return field_trials_; }
protected: protected:
webrtc::test::ScopedKeyValueConfig field_trials_; test::ScopedKeyValueConfig field_trials_;
}; };
} // namespace webrtc } // namespace webrtc

8
pc/test/fake_peer_connection_for_stats.h
View File

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

4
pc/test/fake_periodic_video_source.h
View File

@ -65,12 +65,12 @@ class FakePeriodicVideoSource final
return wants_; return wants_;
} }
void RemoveSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override { void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override {
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
broadcaster_.RemoveSink(sink); broadcaster_.RemoveSink(sink);
} }
void AddOrUpdateSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink, void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
const rtc::VideoSinkWants& wants) override { const rtc::VideoSinkWants& wants) override {
RTC_DCHECK(thread_checker_.IsCurrent()); 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( int FindFirstMediaStatsIndexByKind(
const std::string& kind, 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++) { for (size_t i = 0; i < inbound_rtps.size(); i++) {
if (*inbound_rtps[i]->kind == kind) { if (*inbound_rtps[i]->kind == kind) {
return i; return i;

215
pc/test/integration_test_helpers.h
View File

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

9
pc/test/svc_e2e_tests.cc
View File

@ -160,10 +160,9 @@ std::string SvcTestNameGenerator(
// encoder and decoder level. // encoder and decoder level.
class SvcVideoQualityAnalyzer : public DefaultVideoQualityAnalyzer { class SvcVideoQualityAnalyzer : public DefaultVideoQualityAnalyzer {
public: public:
using SpatialTemporalLayerCounts = using SpatialTemporalLayerCounts = flat_map<int, flat_map<int, int>>;
webrtc::flat_map<int, webrtc::flat_map<int, int>>;
explicit SvcVideoQualityAnalyzer(webrtc::Clock* clock) explicit SvcVideoQualityAnalyzer(Clock* clock)
: DefaultVideoQualityAnalyzer(clock, : DefaultVideoQualityAnalyzer(clock,
test::GetGlobalMetricsLogger(), test::GetGlobalMetricsLogger(),
DefaultVideoQualityAnalyzerOptions{ DefaultVideoQualityAnalyzerOptions{
@ -315,9 +314,9 @@ TEST_P(SvcTest, ScalabilityModeSupported) {
if (UseDependencyDescriptor()) { if (UseDependencyDescriptor()) {
trials += "WebRTC-DependencyDescriptorAdvertised/Enabled/"; trials += "WebRTC-DependencyDescriptorAdvertised/Enabled/";
} }
webrtc::test::ScopedFieldTrials override_trials(AppendFieldTrials(trials)); test::ScopedFieldTrials override_trials(AppendFieldTrials(trials));
std::unique_ptr<NetworkEmulationManager> network_emulation_manager = std::unique_ptr<NetworkEmulationManager> network_emulation_manager =
CreateNetworkEmulationManager(webrtc::TimeMode::kSimulated); CreateNetworkEmulationManager(TimeMode::kSimulated);
auto analyzer = std::make_unique<SvcVideoQualityAnalyzer>( auto analyzer = std::make_unique<SvcVideoQualityAnalyzer>(
network_emulation_manager->time_controller()->GetClock()); network_emulation_manager->time_controller()->GetClock());
SvcVideoQualityAnalyzer* analyzer_ptr = analyzer.get(); 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); }); [&]() { receiver_->SetMediaChannel(media_channel); });
} }
webrtc::VideoTrackSourceInterface* Source() { VideoTrackSourceInterface* Source() {
return receiver_->streams()[0]->FindVideoTrack("receiver")->GetSource(); 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 { class TestFrame : public RecordableEncodedFrame {
public: public:
rtc::scoped_refptr<const webrtc::EncodedImageBufferInterface> encoded_buffer() rtc::scoped_refptr<const EncodedImageBufferInterface> encoded_buffer()
const override { const override {
return nullptr; return nullptr;
} }
absl::optional<webrtc::ColorSpace> color_space() const override { absl::optional<ColorSpace> color_space() const override {
return absl::nullopt; return absl::nullopt;
} }
VideoCodecType codec() const override { return kVideoCodecGeneric; } 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. // Implements ObserverInterface. Observes `video_source_` state.
void OnChanged() override; void OnChanged() override;
RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker signaling_thread_; RTC_NO_UNIQUE_ADDRESS SequenceChecker signaling_thread_;
rtc::Thread* const worker_thread_; rtc::Thread* const worker_thread_;
const rtc::scoped_refptr< const rtc::scoped_refptr<
VideoTrackSourceProxyWithInternal<VideoTrackSourceInterface>> VideoTrackSourceProxyWithInternal<VideoTrackSourceInterface>>

2
pc/video_track_source_proxy.h
View File

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

2
pc/webrtc_sdp.cc
View File

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