diff --git a/webrtc/pc/peerconnectionendtoend_unittest.cc b/webrtc/pc/peerconnectionendtoend_unittest.cc index df41dac2a8..f2a9641c11 100644 --- a/webrtc/pc/peerconnectionendtoend_unittest.cc +++ b/webrtc/pc/peerconnectionendtoend_unittest.cc @@ -10,19 +10,28 @@ #include +#include "webrtc/api/audio_codecs/builtin_audio_decoder_factory.h" #include "webrtc/base/gunit.h" #include "webrtc/base/logging.h" +#include "webrtc/base/ptr_util.h" #include "webrtc/base/ssladapter.h" -#include "webrtc/base/thread.h" #include "webrtc/base/sslstreamadapter.h" #include "webrtc/base/stringencode.h" #include "webrtc/base/stringutils.h" +#include "webrtc/base/thread.h" #ifdef WEBRTC_ANDROID #include "webrtc/pc/test/androidtestinitializer.h" #endif #include "webrtc/pc/test/peerconnectiontestwrapper.h" // Notice that mockpeerconnectionobservers.h must be included after the above! #include "webrtc/pc/test/mockpeerconnectionobservers.h" +#include "webrtc/test/mock_audio_decoder.h" +#include "webrtc/test/mock_audio_decoder_factory.h" + +using testing::AtLeast; +using testing::Invoke; +using testing::StrictMock; +using testing::_; using webrtc::DataChannelInterface; using webrtc::FakeConstraints; @@ -59,13 +68,14 @@ class PeerConnectionEndToEndTest #endif } - void CreatePcs() { - CreatePcs(NULL); - } - - void CreatePcs(const MediaConstraintsInterface* pc_constraints) { - EXPECT_TRUE(caller_->CreatePc(pc_constraints, config_)); - EXPECT_TRUE(callee_->CreatePc(pc_constraints, config_)); + void CreatePcs( + const MediaConstraintsInterface* pc_constraints, + rtc::scoped_refptr audio_encoder_factory, + rtc::scoped_refptr audio_decoder_factory) { + EXPECT_TRUE(caller_->CreatePc( + pc_constraints, config_, audio_encoder_factory, audio_decoder_factory)); + EXPECT_TRUE(callee_->CreatePc( + pc_constraints, config_, audio_encoder_factory, audio_decoder_factory)); PeerConnectionTestWrapper::Connect(caller_.get(), callee_.get()); caller_->SignalOnDataChannel.connect( @@ -163,13 +173,99 @@ class PeerConnectionEndToEndTest webrtc::PeerConnectionInterface::RTCConfiguration config_; }; +std::unique_ptr CreateForwardingMockDecoder( + std::unique_ptr real_decoder) { + class ForwardingMockDecoder : public StrictMock { + public: + ForwardingMockDecoder(std::unique_ptr decoder) + : decoder_(std::move(decoder)) {} + + private: + std::unique_ptr decoder_; + }; + + const auto dec = real_decoder.get(); // For lambda capturing. + auto mock_decoder = + rtc::MakeUnique(std::move(real_decoder)); + EXPECT_CALL(*mock_decoder, Channels()) + .Times(AtLeast(1)) + .WillRepeatedly(Invoke([dec] { return dec->Channels(); })); + EXPECT_CALL(*mock_decoder, DecodeInternal(_, _, _, _, _)) + .Times(AtLeast(1)) + .WillRepeatedly( + Invoke([dec](const uint8_t* encoded, size_t encoded_len, + int sample_rate_hz, int16_t* decoded, + webrtc::AudioDecoder::SpeechType* speech_type) { + return dec->Decode(encoded, encoded_len, sample_rate_hz, + std::numeric_limits::max(), decoded, + speech_type); + })); + EXPECT_CALL(*mock_decoder, Die()); + EXPECT_CALL(*mock_decoder, HasDecodePlc()).WillRepeatedly(Invoke([dec] { + return dec->HasDecodePlc(); + })); + EXPECT_CALL(*mock_decoder, IncomingPacket(_, _, _, _, _)) + .Times(AtLeast(1)) + .WillRepeatedly(Invoke([dec](const uint8_t* payload, size_t payload_len, + uint16_t rtp_sequence_number, + uint32_t rtp_timestamp, + uint32_t arrival_timestamp) { + return dec->IncomingPacket(payload, payload_len, rtp_sequence_number, + rtp_timestamp, arrival_timestamp); + })); + EXPECT_CALL(*mock_decoder, PacketDuration(_, _)) + .Times(AtLeast(1)) + .WillRepeatedly(Invoke([dec](const uint8_t* encoded, size_t encoded_len) { + return dec->PacketDuration(encoded, encoded_len); + })); + EXPECT_CALL(*mock_decoder, SampleRateHz()) + .Times(AtLeast(1)) + .WillRepeatedly(Invoke([dec] { return dec->SampleRateHz(); })); + + return std::move(mock_decoder); +} + +rtc::scoped_refptr +CreateForwardingMockDecoderFactory( + webrtc::AudioDecoderFactory* real_decoder_factory) { + rtc::scoped_refptr mock_decoder_factory = + new rtc::RefCountedObject>; + EXPECT_CALL(*mock_decoder_factory, GetSupportedDecoders()) + .Times(AtLeast(1)) + .WillRepeatedly(Invoke([real_decoder_factory] { + return real_decoder_factory->GetSupportedDecoders(); + })); + EXPECT_CALL(*mock_decoder_factory, IsSupportedDecoder(_)) + .Times(AtLeast(1)) + .WillRepeatedly( + Invoke([real_decoder_factory](const webrtc::SdpAudioFormat& format) { + return real_decoder_factory->IsSupportedDecoder(format); + })); + EXPECT_CALL(*mock_decoder_factory, MakeAudioDecoderMock(_, _)) + .Times(AtLeast(2)) + .WillRepeatedly( + Invoke([real_decoder_factory]( + const webrtc::SdpAudioFormat& format, + std::unique_ptr* return_value) { + auto real_decoder = real_decoder_factory->MakeAudioDecoder(format); + *return_value = + real_decoder + ? CreateForwardingMockDecoder(std::move(real_decoder)) + : nullptr; + })); + return mock_decoder_factory; +} + // Disabled for TSan v2, see // https://bugs.chromium.org/p/webrtc/issues/detail?id=4719 for details. // Disabled for Mac, see // https://bugs.chromium.org/p/webrtc/issues/detail?id=5231 for details. #if !defined(THREAD_SANITIZER) && !defined(WEBRTC_MAC) TEST_F(PeerConnectionEndToEndTest, Call) { - CreatePcs(); + rtc::scoped_refptr real_decoder_factory = + webrtc::CreateBuiltinAudioDecoderFactory(); + CreatePcs(nullptr, webrtc::CreateBuiltinAudioEncoderFactory(), + CreateForwardingMockDecoderFactory(real_decoder_factory.get())); GetAndAddUserMedia(); Negotiate(); WaitForCallEstablished(); @@ -181,7 +277,8 @@ TEST_F(PeerConnectionEndToEndTest, CallWithLegacySdp) { FakeConstraints pc_constraints; pc_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp, false); - CreatePcs(&pc_constraints); + CreatePcs(&pc_constraints, webrtc::CreateBuiltinAudioEncoderFactory(), + webrtc::CreateBuiltinAudioDecoderFactory()); GetAndAddUserMedia(); Negotiate(); WaitForCallEstablished(); @@ -192,7 +289,8 @@ TEST_F(PeerConnectionEndToEndTest, CallWithLegacySdp) { // Verifies that a DataChannel created before the negotiation can transition to // "OPEN" and transfer data. TEST_F(PeerConnectionEndToEndTest, CreateDataChannelBeforeNegotiate) { - CreatePcs(); + CreatePcs(nullptr, webrtc::CreateBuiltinAudioEncoderFactory(), + webrtc::CreateBuiltinAudioDecoderFactory()); webrtc::DataChannelInit init; rtc::scoped_refptr caller_dc( @@ -216,7 +314,8 @@ TEST_F(PeerConnectionEndToEndTest, CreateDataChannelBeforeNegotiate) { // Verifies that a DataChannel created after the negotiation can transition to // "OPEN" and transfer data. TEST_F(PeerConnectionEndToEndTest, CreateDataChannelAfterNegotiate) { - CreatePcs(); + CreatePcs(nullptr, webrtc::CreateBuiltinAudioEncoderFactory(), + webrtc::CreateBuiltinAudioDecoderFactory()); webrtc::DataChannelInit init; @@ -247,7 +346,8 @@ TEST_F(PeerConnectionEndToEndTest, CreateDataChannelAfterNegotiate) { // Verifies that DataChannel IDs are even/odd based on the DTLS roles. TEST_F(PeerConnectionEndToEndTest, DataChannelIdAssignment) { - CreatePcs(); + CreatePcs(nullptr, webrtc::CreateBuiltinAudioEncoderFactory(), + webrtc::CreateBuiltinAudioDecoderFactory()); webrtc::DataChannelInit init; rtc::scoped_refptr caller_dc_1( @@ -274,7 +374,8 @@ TEST_F(PeerConnectionEndToEndTest, DataChannelIdAssignment) { // there are multiple DataChannels. TEST_F(PeerConnectionEndToEndTest, MessageTransferBetweenTwoPairsOfDataChannels) { - CreatePcs(); + CreatePcs(nullptr, webrtc::CreateBuiltinAudioEncoderFactory(), + webrtc::CreateBuiltinAudioDecoderFactory()); webrtc::DataChannelInit init; @@ -395,7 +496,8 @@ TEST_F(PeerConnectionEndToEndTest, MessageTransferBetweenQuicDataChannels) { // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=4453 TEST_F(PeerConnectionEndToEndTest, DISABLED_DataChannelFromOpenWorksAfterClose) { - CreatePcs(); + CreatePcs(nullptr, webrtc::CreateBuiltinAudioEncoderFactory(), + webrtc::CreateBuiltinAudioDecoderFactory()); webrtc::DataChannelInit init; rtc::scoped_refptr caller_dc( @@ -421,7 +523,8 @@ TEST_F(PeerConnectionEndToEndTest, // reference count), no memory access violation will occur. // See: https://code.google.com/p/chromium/issues/detail?id=565048 TEST_F(PeerConnectionEndToEndTest, CloseDataChannelRemotelyWhileNotReferenced) { - CreatePcs(); + CreatePcs(nullptr, webrtc::CreateBuiltinAudioEncoderFactory(), + webrtc::CreateBuiltinAudioDecoderFactory()); webrtc::DataChannelInit init; rtc::scoped_refptr caller_dc( diff --git a/webrtc/pc/rtcstats_integrationtest.cc b/webrtc/pc/rtcstats_integrationtest.cc index 922e07c12a..a2bfb3ee6a 100644 --- a/webrtc/pc/rtcstats_integrationtest.cc +++ b/webrtc/pc/rtcstats_integrationtest.cc @@ -11,6 +11,7 @@ #include #include +#include "webrtc/api/audio_codecs/builtin_audio_decoder_factory.h" #include "webrtc/api/datachannelinterface.h" #include "webrtc/api/peerconnectioninterface.h" #include "webrtc/api/stats/rtcstats_objects.h" @@ -52,8 +53,12 @@ class RTCStatsIntegrationTest : public testing::Test { PeerConnectionInterface::IceServer ice_server; ice_server.uri = "stun:1.1.1.1:3478"; config.servers.push_back(ice_server); - EXPECT_TRUE(caller_->CreatePc(nullptr, config)); - EXPECT_TRUE(callee_->CreatePc(nullptr, config)); + EXPECT_TRUE(caller_->CreatePc(nullptr, config, + CreateBuiltinAudioEncoderFactory(), + CreateBuiltinAudioDecoderFactory())); + EXPECT_TRUE(callee_->CreatePc(nullptr, config, + CreateBuiltinAudioEncoderFactory(), + CreateBuiltinAudioDecoderFactory())); PeerConnectionTestWrapper::Connect(caller_.get(), callee_.get()); // Get user media for audio and video diff --git a/webrtc/pc/test/peerconnectiontestwrapper.cc b/webrtc/pc/test/peerconnectiontestwrapper.cc index e5ead481b8..f1bf21d53f 100644 --- a/webrtc/pc/test/peerconnectiontestwrapper.cc +++ b/webrtc/pc/test/peerconnectiontestwrapper.cc @@ -59,7 +59,9 @@ PeerConnectionTestWrapper::~PeerConnectionTestWrapper() {} bool PeerConnectionTestWrapper::CreatePc( const MediaConstraintsInterface* constraints, - const webrtc::PeerConnectionInterface::RTCConfiguration& config) { + const webrtc::PeerConnectionInterface::RTCConfiguration& config, + rtc::scoped_refptr audio_encoder_factory, + rtc::scoped_refptr audio_decoder_factory) { std::unique_ptr port_allocator( new cricket::FakePortAllocator(network_thread_, nullptr)); @@ -70,7 +72,8 @@ bool PeerConnectionTestWrapper::CreatePc( peer_connection_factory_ = webrtc::CreatePeerConnectionFactory( network_thread_, worker_thread_, rtc::Thread::Current(), - fake_audio_capture_module_, NULL, NULL); + fake_audio_capture_module_, audio_encoder_factory, audio_decoder_factory, + nullptr, nullptr); if (!peer_connection_factory_) { return false; } diff --git a/webrtc/pc/test/peerconnectiontestwrapper.h b/webrtc/pc/test/peerconnectiontestwrapper.h index 6b7fd5e95b..124e63d847 100644 --- a/webrtc/pc/test/peerconnectiontestwrapper.h +++ b/webrtc/pc/test/peerconnectiontestwrapper.h @@ -34,7 +34,9 @@ class PeerConnectionTestWrapper bool CreatePc( const webrtc::MediaConstraintsInterface* constraints, - const webrtc::PeerConnectionInterface::RTCConfiguration& config); + const webrtc::PeerConnectionInterface::RTCConfiguration& config, + rtc::scoped_refptr audio_encoder_factory, + rtc::scoped_refptr audio_decoder_factory); webrtc::PeerConnectionInterface* pc() { return peer_connection_.get(); }