| /* | |
| * Copyright 2012 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. | |
| */ | |
| #include <stdio.h> | |
| #include <algorithm> | |
| #include <list> | |
| #include <map> | |
| #include <memory> | |
| #include <utility> | |
| #include <vector> | |
| #include "webrtc/api/dtmfsender.h" | |
| #include "webrtc/api/fakemetricsobserver.h" | |
| #include "webrtc/api/localaudiosource.h" | |
| #include "webrtc/api/mediastreaminterface.h" | |
| #include "webrtc/api/peerconnection.h" | |
| #include "webrtc/api/peerconnectionfactory.h" | |
| #include "webrtc/api/peerconnectioninterface.h" | |
| #include "webrtc/api/test/fakeaudiocapturemodule.h" | |
| #include "webrtc/api/test/fakeconstraints.h" | |
| #include "webrtc/api/test/fakeperiodicvideocapturer.h" | |
| #include "webrtc/api/test/fakertccertificategenerator.h" | |
| #include "webrtc/api/test/fakevideotrackrenderer.h" | |
| #include "webrtc/api/test/mockpeerconnectionobservers.h" | |
| #include "webrtc/base/gunit.h" | |
| #include "webrtc/base/helpers.h" | |
| #include "webrtc/base/physicalsocketserver.h" | |
| #include "webrtc/base/ssladapter.h" | |
| #include "webrtc/base/sslstreamadapter.h" | |
| #include "webrtc/base/thread.h" | |
| #include "webrtc/base/virtualsocketserver.h" | |
| #include "webrtc/media/engine/fakewebrtcvideoengine.h" | |
| #include "webrtc/p2p/base/fakeportallocator.h" | |
| #include "webrtc/p2p/base/p2pconstants.h" | |
| #include "webrtc/p2p/base/sessiondescription.h" | |
| #include "webrtc/pc/mediasession.h" | |
| #define MAYBE_SKIP_TEST(feature) \ | |
| if (!(feature())) { \ | |
| LOG(LS_INFO) << "Feature disabled... skipping"; \ | |
| return; \ | |
| } | |
| using cricket::ContentInfo; | |
| using cricket::FakeWebRtcVideoDecoder; | |
| using cricket::FakeWebRtcVideoDecoderFactory; | |
| using cricket::FakeWebRtcVideoEncoder; | |
| using cricket::FakeWebRtcVideoEncoderFactory; | |
| using cricket::MediaContentDescription; | |
| using webrtc::DataBuffer; | |
| using webrtc::DataChannelInterface; | |
| using webrtc::DtmfSender; | |
| using webrtc::DtmfSenderInterface; | |
| using webrtc::DtmfSenderObserverInterface; | |
| using webrtc::FakeConstraints; | |
| using webrtc::MediaConstraintsInterface; | |
| using webrtc::MediaStreamInterface; | |
| using webrtc::MediaStreamTrackInterface; | |
| using webrtc::MockCreateSessionDescriptionObserver; | |
| using webrtc::MockDataChannelObserver; | |
| using webrtc::MockSetSessionDescriptionObserver; | |
| using webrtc::MockStatsObserver; | |
| using webrtc::ObserverInterface; | |
| using webrtc::PeerConnectionInterface; | |
| using webrtc::PeerConnectionFactory; | |
| using webrtc::SessionDescriptionInterface; | |
| using webrtc::StreamCollectionInterface; | |
| namespace { | |
| static const int kMaxWaitMs = 10000; | |
| // Disable for TSan v2, see | |
| // https://code.google.com/p/webrtc/issues/detail?id=1205 for details. | |
| // This declaration is also #ifdef'd as it causes uninitialized-variable | |
| // warnings. | |
| #if !defined(THREAD_SANITIZER) | |
| static const int kMaxWaitForStatsMs = 3000; | |
| #endif | |
| static const int kMaxWaitForActivationMs = 5000; | |
| static const int kMaxWaitForFramesMs = 10000; | |
| static const int kEndAudioFrameCount = 3; | |
| static const int kEndVideoFrameCount = 3; | |
| static const char kStreamLabelBase[] = "stream_label"; | |
| static const char kVideoTrackLabelBase[] = "video_track"; | |
| static const char kAudioTrackLabelBase[] = "audio_track"; | |
| static const char kDataChannelLabel[] = "data_channel"; | |
| // Disable for TSan v2, see | |
| // https://code.google.com/p/webrtc/issues/detail?id=1205 for details. | |
| // This declaration is also #ifdef'd as it causes unused-variable errors. | |
| #if !defined(THREAD_SANITIZER) | |
| // SRTP cipher name negotiated by the tests. This must be updated if the | |
| // default changes. | |
| static const int kDefaultSrtpCryptoSuite = rtc::SRTP_AES128_CM_SHA1_32; | |
| static const int kDefaultSrtpCryptoSuiteGcm = rtc::SRTP_AEAD_AES_256_GCM; | |
| #endif | |
| static void RemoveLinesFromSdp(const std::string& line_start, | |
| std::string* sdp) { | |
| const char kSdpLineEnd[] = "\r\n"; | |
| size_t ssrc_pos = 0; | |
| while ((ssrc_pos = sdp->find(line_start, ssrc_pos)) != | |
| std::string::npos) { | |
| size_t end_ssrc = sdp->find(kSdpLineEnd, ssrc_pos); | |
| sdp->erase(ssrc_pos, end_ssrc - ssrc_pos + strlen(kSdpLineEnd)); | |
| } | |
| } | |
| bool StreamsHaveAudioTrack(StreamCollectionInterface* streams) { | |
| for (size_t idx = 0; idx < streams->count(); idx++) { | |
| auto stream = streams->at(idx); | |
| if (stream->GetAudioTracks().size() > 0) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool StreamsHaveVideoTrack(StreamCollectionInterface* streams) { | |
| for (size_t idx = 0; idx < streams->count(); idx++) { | |
| auto stream = streams->at(idx); | |
| if (stream->GetVideoTracks().size() > 0) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| class SignalingMessageReceiver { | |
| public: | |
| virtual void ReceiveSdpMessage(const std::string& type, | |
| std::string& msg) = 0; | |
| virtual void ReceiveIceMessage(const std::string& sdp_mid, | |
| int sdp_mline_index, | |
| const std::string& msg) = 0; | |
| protected: | |
| SignalingMessageReceiver() {} | |
| virtual ~SignalingMessageReceiver() {} | |
| }; | |
| class MockRtpReceiverObserver : public webrtc::RtpReceiverObserverInterface { | |
| public: | |
| MockRtpReceiverObserver(cricket::MediaType media_type) | |
| : expected_media_type_(media_type) {} | |
| void OnFirstPacketReceived(cricket::MediaType media_type) override { | |
| ASSERT_EQ(expected_media_type_, media_type); | |
| first_packet_received_ = true; | |
| } | |
| bool first_packet_received() { return first_packet_received_; } | |
| virtual ~MockRtpReceiverObserver() {} | |
| private: | |
| bool first_packet_received_ = false; | |
| cricket::MediaType expected_media_type_; | |
| }; | |
| class PeerConnectionTestClient : public webrtc::PeerConnectionObserver, | |
| public SignalingMessageReceiver, | |
| public ObserverInterface { | |
| public: | |
| static PeerConnectionTestClient* CreateClientWithDtlsIdentityStore( | |
| const std::string& id, | |
| const MediaConstraintsInterface* constraints, | |
| const PeerConnectionFactory::Options* options, | |
| const PeerConnectionInterface::RTCConfiguration& config, | |
| std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator, | |
| bool prefer_constraint_apis, | |
| rtc::Thread* network_thread, | |
| rtc::Thread* worker_thread) { | |
| PeerConnectionTestClient* client(new PeerConnectionTestClient(id)); | |
| if (!client->Init(constraints, options, config, std::move(cert_generator), | |
| prefer_constraint_apis, network_thread, worker_thread)) { | |
| delete client; | |
| return nullptr; | |
| } | |
| return client; | |
| } | |
| static PeerConnectionTestClient* CreateClient( | |
| const std::string& id, | |
| const MediaConstraintsInterface* constraints, | |
| const PeerConnectionFactory::Options* options, | |
| const PeerConnectionInterface::RTCConfiguration& config, | |
| rtc::Thread* network_thread, | |
| rtc::Thread* worker_thread) { | |
| std::unique_ptr<FakeRTCCertificateGenerator> cert_generator( | |
| rtc::SSLStreamAdapter::HaveDtlsSrtp() ? | |
| new FakeRTCCertificateGenerator() : nullptr); | |
| return CreateClientWithDtlsIdentityStore(id, constraints, options, config, | |
| std::move(cert_generator), true, | |
| network_thread, worker_thread); | |
| } | |
| static PeerConnectionTestClient* CreateClientPreferNoConstraints( | |
| const std::string& id, | |
| const PeerConnectionFactory::Options* options, | |
| const PeerConnectionInterface::RTCConfiguration& config, | |
| rtc::Thread* network_thread, | |
| rtc::Thread* worker_thread) { | |
| std::unique_ptr<FakeRTCCertificateGenerator> cert_generator( | |
| rtc::SSLStreamAdapter::HaveDtlsSrtp() ? | |
| new FakeRTCCertificateGenerator() : nullptr); | |
| return CreateClientWithDtlsIdentityStore(id, nullptr, options, config, | |
| std::move(cert_generator), false, | |
| network_thread, worker_thread); | |
| } | |
| ~PeerConnectionTestClient() { | |
| } | |
| void Negotiate() { Negotiate(true, true); } | |
| void Negotiate(bool audio, bool video) { | |
| std::unique_ptr<SessionDescriptionInterface> offer; | |
| ASSERT_TRUE(DoCreateOffer(&offer)); | |
| if (offer->description()->GetContentByName("audio")) { | |
| offer->description()->GetContentByName("audio")->rejected = !audio; | |
| } | |
| if (offer->description()->GetContentByName("video")) { | |
| offer->description()->GetContentByName("video")->rejected = !video; | |
| } | |
| std::string sdp; | |
| EXPECT_TRUE(offer->ToString(&sdp)); | |
| EXPECT_TRUE(DoSetLocalDescription(offer.release())); | |
| signaling_message_receiver_->ReceiveSdpMessage( | |
| webrtc::SessionDescriptionInterface::kOffer, sdp); | |
| } | |
| // SignalingMessageReceiver callback. | |
| void ReceiveSdpMessage(const std::string& type, std::string& msg) override { | |
| FilterIncomingSdpMessage(&msg); | |
| if (type == webrtc::SessionDescriptionInterface::kOffer) { | |
| HandleIncomingOffer(msg); | |
| } else { | |
| HandleIncomingAnswer(msg); | |
| } | |
| } | |
| // SignalingMessageReceiver callback. | |
| void ReceiveIceMessage(const std::string& sdp_mid, | |
| int sdp_mline_index, | |
| const std::string& msg) override { | |
| LOG(INFO) << id_ << "ReceiveIceMessage"; | |
| std::unique_ptr<webrtc::IceCandidateInterface> candidate( | |
| webrtc::CreateIceCandidate(sdp_mid, sdp_mline_index, msg, nullptr)); | |
| EXPECT_TRUE(pc()->AddIceCandidate(candidate.get())); | |
| } | |
| // PeerConnectionObserver callbacks. | |
| void OnSignalingChange( | |
| webrtc::PeerConnectionInterface::SignalingState new_state) override { | |
| EXPECT_EQ(pc()->signaling_state(), new_state); | |
| } | |
| void OnAddStream( | |
| rtc::scoped_refptr<MediaStreamInterface> media_stream) override { | |
| media_stream->RegisterObserver(this); | |
| for (size_t i = 0; i < media_stream->GetVideoTracks().size(); ++i) { | |
| const std::string id = media_stream->GetVideoTracks()[i]->id(); | |
| ASSERT_TRUE(fake_video_renderers_.find(id) == | |
| fake_video_renderers_.end()); | |
| fake_video_renderers_[id].reset(new webrtc::FakeVideoTrackRenderer( | |
| media_stream->GetVideoTracks()[i])); | |
| } | |
| } | |
| void OnRemoveStream( | |
| rtc::scoped_refptr<MediaStreamInterface> media_stream) override {} | |
| void OnRenegotiationNeeded() override {} | |
| void OnIceConnectionChange( | |
| webrtc::PeerConnectionInterface::IceConnectionState new_state) override { | |
| EXPECT_EQ(pc()->ice_connection_state(), new_state); | |
| } | |
| void OnIceGatheringChange( | |
| webrtc::PeerConnectionInterface::IceGatheringState new_state) override { | |
| EXPECT_EQ(pc()->ice_gathering_state(), new_state); | |
| } | |
| void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override { | |
| LOG(INFO) << id_ << "OnIceCandidate"; | |
| std::string ice_sdp; | |
| EXPECT_TRUE(candidate->ToString(&ice_sdp)); | |
| if (signaling_message_receiver_ == nullptr) { | |
| // Remote party may be deleted. | |
| return; | |
| } | |
| signaling_message_receiver_->ReceiveIceMessage( | |
| candidate->sdp_mid(), candidate->sdp_mline_index(), ice_sdp); | |
| } | |
| // MediaStreamInterface callback | |
| void OnChanged() override { | |
| // Track added or removed from MediaStream, so update our renderers. | |
| rtc::scoped_refptr<StreamCollectionInterface> remote_streams = | |
| pc()->remote_streams(); | |
| // Remove renderers for tracks that were removed. | |
| for (auto it = fake_video_renderers_.begin(); | |
| it != fake_video_renderers_.end();) { | |
| if (remote_streams->FindVideoTrack(it->first) == nullptr) { | |
| auto to_remove = it++; | |
| removed_fake_video_renderers_.push_back(std::move(to_remove->second)); | |
| fake_video_renderers_.erase(to_remove); | |
| } else { | |
| ++it; | |
| } | |
| } | |
| // Create renderers for new video tracks. | |
| for (size_t stream_index = 0; stream_index < remote_streams->count(); | |
| ++stream_index) { | |
| MediaStreamInterface* remote_stream = remote_streams->at(stream_index); | |
| for (size_t track_index = 0; | |
| track_index < remote_stream->GetVideoTracks().size(); | |
| ++track_index) { | |
| const std::string id = | |
| remote_stream->GetVideoTracks()[track_index]->id(); | |
| if (fake_video_renderers_.find(id) != fake_video_renderers_.end()) { | |
| continue; | |
| } | |
| fake_video_renderers_[id].reset(new webrtc::FakeVideoTrackRenderer( | |
| remote_stream->GetVideoTracks()[track_index])); | |
| } | |
| } | |
| } | |
| void SetVideoConstraints(const webrtc::FakeConstraints& video_constraint) { | |
| video_constraints_ = video_constraint; | |
| } | |
| void AddMediaStream(bool audio, bool video) { | |
| std::string stream_label = | |
| kStreamLabelBase + | |
| rtc::ToString<int>(static_cast<int>(pc()->local_streams()->count())); | |
| rtc::scoped_refptr<MediaStreamInterface> stream = | |
| peer_connection_factory_->CreateLocalMediaStream(stream_label); | |
| if (audio && can_receive_audio()) { | |
| stream->AddTrack(CreateLocalAudioTrack(stream_label)); | |
| } | |
| if (video && can_receive_video()) { | |
| stream->AddTrack(CreateLocalVideoTrack(stream_label)); | |
| } | |
| EXPECT_TRUE(pc()->AddStream(stream)); | |
| } | |
| size_t NumberOfLocalMediaStreams() { return pc()->local_streams()->count(); } | |
| bool SessionActive() { | |
| return pc()->signaling_state() == webrtc::PeerConnectionInterface::kStable; | |
| } | |
| // Automatically add a stream when receiving an offer, if we don't have one. | |
| // Defaults to true. | |
| void set_auto_add_stream(bool auto_add_stream) { | |
| auto_add_stream_ = auto_add_stream; | |
| } | |
| void set_signaling_message_receiver( | |
| SignalingMessageReceiver* signaling_message_receiver) { | |
| signaling_message_receiver_ = signaling_message_receiver; | |
| } | |
| void EnableVideoDecoderFactory() { | |
| video_decoder_factory_enabled_ = true; | |
| fake_video_decoder_factory_->AddSupportedVideoCodecType( | |
| webrtc::kVideoCodecVP8); | |
| } | |
| void IceRestart() { | |
| offer_answer_constraints_.SetMandatoryIceRestart(true); | |
| offer_answer_options_.ice_restart = true; | |
| SetExpectIceRestart(true); | |
| } | |
| void SetExpectIceRestart(bool expect_restart) { | |
| expect_ice_restart_ = expect_restart; | |
| } | |
| bool ExpectIceRestart() const { return expect_ice_restart_; } | |
| void SetExpectIceRenomination(bool expect_renomination) { | |
| expect_ice_renomination_ = expect_renomination; | |
| } | |
| void SetExpectRemoteIceRenomination(bool expect_renomination) { | |
| expect_remote_ice_renomination_ = expect_renomination; | |
| } | |
| bool ExpectIceRenomination() { return expect_ice_renomination_; } | |
| bool ExpectRemoteIceRenomination() { return expect_remote_ice_renomination_; } | |
| void SetReceiveAudioVideo(bool audio, bool video) { | |
| SetReceiveAudio(audio); | |
| SetReceiveVideo(video); | |
| ASSERT_EQ(audio, can_receive_audio()); | |
| ASSERT_EQ(video, can_receive_video()); | |
| } | |
| void SetReceiveAudio(bool audio) { | |
| if (audio && can_receive_audio()) | |
| return; | |
| offer_answer_constraints_.SetMandatoryReceiveAudio(audio); | |
| offer_answer_options_.offer_to_receive_audio = audio ? 1 : 0; | |
| } | |
| void SetReceiveVideo(bool video) { | |
| if (video && can_receive_video()) | |
| return; | |
| offer_answer_constraints_.SetMandatoryReceiveVideo(video); | |
| offer_answer_options_.offer_to_receive_video = video ? 1 : 0; | |
| } | |
| void RemoveMsidFromReceivedSdp(bool remove) { remove_msid_ = remove; } | |
| void RemoveSdesCryptoFromReceivedSdp(bool remove) { remove_sdes_ = remove; } | |
| void RemoveBundleFromReceivedSdp(bool remove) { remove_bundle_ = remove; } | |
| void RemoveCvoFromReceivedSdp(bool remove) { remove_cvo_ = remove; } | |
| bool can_receive_audio() { | |
| bool value; | |
| if (prefer_constraint_apis_) { | |
| if (webrtc::FindConstraint( | |
| &offer_answer_constraints_, | |
| MediaConstraintsInterface::kOfferToReceiveAudio, &value, | |
| nullptr)) { | |
| return value; | |
| } | |
| return true; | |
| } | |
| return offer_answer_options_.offer_to_receive_audio > 0 || | |
| offer_answer_options_.offer_to_receive_audio == | |
| PeerConnectionInterface::RTCOfferAnswerOptions::kUndefined; | |
| } | |
| bool can_receive_video() { | |
| bool value; | |
| if (prefer_constraint_apis_) { | |
| if (webrtc::FindConstraint( | |
| &offer_answer_constraints_, | |
| MediaConstraintsInterface::kOfferToReceiveVideo, &value, | |
| nullptr)) { | |
| return value; | |
| } | |
| return true; | |
| } | |
| return offer_answer_options_.offer_to_receive_video > 0 || | |
| offer_answer_options_.offer_to_receive_video == | |
| PeerConnectionInterface::RTCOfferAnswerOptions::kUndefined; | |
| } | |
| void OnDataChannel( | |
| rtc::scoped_refptr<DataChannelInterface> data_channel) override { | |
| LOG(INFO) << id_ << "OnDataChannel"; | |
| data_channel_ = data_channel; | |
| data_observer_.reset(new MockDataChannelObserver(data_channel)); | |
| } | |
| void CreateDataChannel() { CreateDataChannel(nullptr); } | |
| void CreateDataChannel(const webrtc::DataChannelInit* init) { | |
| data_channel_ = pc()->CreateDataChannel(kDataChannelLabel, init); | |
| ASSERT_TRUE(data_channel_.get() != nullptr); | |
| data_observer_.reset(new MockDataChannelObserver(data_channel_)); | |
| } | |
| rtc::scoped_refptr<webrtc::AudioTrackInterface> CreateLocalAudioTrack( | |
| const std::string& stream_label) { | |
| FakeConstraints constraints; | |
| // Disable highpass filter so that we can get all the test audio frames. | |
| constraints.AddMandatory(MediaConstraintsInterface::kHighpassFilter, false); | |
| rtc::scoped_refptr<webrtc::AudioSourceInterface> source = | |
| peer_connection_factory_->CreateAudioSource(&constraints); | |
| // TODO(perkj): Test audio source when it is implemented. Currently audio | |
| // always use the default input. | |
| std::string label = stream_label + kAudioTrackLabelBase; | |
| return peer_connection_factory_->CreateAudioTrack(label, source); | |
| } | |
| rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrack( | |
| const std::string& stream_label) { | |
| // Set max frame rate to 10fps to reduce the risk of the tests to be flaky. | |
| FakeConstraints source_constraints = video_constraints_; | |
| source_constraints.SetMandatoryMaxFrameRate(10); | |
| cricket::FakeVideoCapturer* fake_capturer = | |
| new webrtc::FakePeriodicVideoCapturer(); | |
| fake_capturer->SetRotation(capture_rotation_); | |
| video_capturers_.push_back(fake_capturer); | |
| rtc::scoped_refptr<webrtc::VideoTrackSourceInterface> source = | |
| peer_connection_factory_->CreateVideoSource(fake_capturer, | |
| &source_constraints); | |
| std::string label = stream_label + kVideoTrackLabelBase; | |
| rtc::scoped_refptr<webrtc::VideoTrackInterface> track( | |
| peer_connection_factory_->CreateVideoTrack(label, source)); | |
| if (!local_video_renderer_) { | |
| local_video_renderer_.reset(new webrtc::FakeVideoTrackRenderer(track)); | |
| } | |
| return track; | |
| } | |
| DataChannelInterface* data_channel() { return data_channel_; } | |
| const MockDataChannelObserver* data_observer() const { | |
| return data_observer_.get(); | |
| } | |
| webrtc::PeerConnectionInterface* pc() const { return peer_connection_.get(); } | |
| void StopVideoCapturers() { | |
| for (auto* capturer : video_capturers_) { | |
| capturer->Stop(); | |
| } | |
| } | |
| void SetCaptureRotation(webrtc::VideoRotation rotation) { | |
| ASSERT_TRUE(video_capturers_.empty()); | |
| capture_rotation_ = rotation; | |
| } | |
| bool AudioFramesReceivedCheck(int number_of_frames) const { | |
| return number_of_frames <= fake_audio_capture_module_->frames_received(); | |
| } | |
| int audio_frames_received() const { | |
| return fake_audio_capture_module_->frames_received(); | |
| } | |
| bool VideoFramesReceivedCheck(int number_of_frames) { | |
| if (video_decoder_factory_enabled_) { | |
| const std::vector<FakeWebRtcVideoDecoder*>& decoders | |
| = fake_video_decoder_factory_->decoders(); | |
| if (decoders.empty()) { | |
| return number_of_frames <= 0; | |
| } | |
| // Note - this checks that EACH decoder has the requisite number | |
| // of frames. The video_frames_received() function sums them. | |
| for (FakeWebRtcVideoDecoder* decoder : decoders) { | |
| if (number_of_frames > decoder->GetNumFramesReceived()) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } else { | |
| if (fake_video_renderers_.empty()) { | |
| return number_of_frames <= 0; | |
| } | |
| for (const auto& pair : fake_video_renderers_) { | |
| if (number_of_frames > pair.second->num_rendered_frames()) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| } | |
| int video_frames_received() const { | |
| int total = 0; | |
| if (video_decoder_factory_enabled_) { | |
| const std::vector<FakeWebRtcVideoDecoder*>& decoders = | |
| fake_video_decoder_factory_->decoders(); | |
| for (const FakeWebRtcVideoDecoder* decoder : decoders) { | |
| total += decoder->GetNumFramesReceived(); | |
| } | |
| } else { | |
| for (const auto& pair : fake_video_renderers_) { | |
| total += pair.second->num_rendered_frames(); | |
| } | |
| for (const auto& renderer : removed_fake_video_renderers_) { | |
| total += renderer->num_rendered_frames(); | |
| } | |
| } | |
| return total; | |
| } | |
| // Verify the CreateDtmfSender interface | |
| void VerifyDtmf() { | |
| std::unique_ptr<DummyDtmfObserver> observer(new DummyDtmfObserver()); | |
| rtc::scoped_refptr<DtmfSenderInterface> dtmf_sender; | |
| // We can't create a DTMF sender with an invalid audio track or a non local | |
| // track. | |
| EXPECT_TRUE(peer_connection_->CreateDtmfSender(nullptr) == nullptr); | |
| rtc::scoped_refptr<webrtc::AudioTrackInterface> non_localtrack( | |
| peer_connection_factory_->CreateAudioTrack("dummy_track", nullptr)); | |
| EXPECT_TRUE(peer_connection_->CreateDtmfSender(non_localtrack) == nullptr); | |
| // We should be able to create a DTMF sender from a local track. | |
| webrtc::AudioTrackInterface* localtrack = | |
| peer_connection_->local_streams()->at(0)->GetAudioTracks()[0]; | |
| dtmf_sender = peer_connection_->CreateDtmfSender(localtrack); | |
| EXPECT_TRUE(dtmf_sender.get() != nullptr); | |
| dtmf_sender->RegisterObserver(observer.get()); | |
| // Test the DtmfSender object just created. | |
| EXPECT_TRUE(dtmf_sender->CanInsertDtmf()); | |
| EXPECT_TRUE(dtmf_sender->InsertDtmf("1a", 100, 50)); | |
| // We don't need to verify that the DTMF tones are actually sent out because | |
| // that is already covered by the tests of the lower level components. | |
| EXPECT_TRUE_WAIT(observer->completed(), kMaxWaitMs); | |
| std::vector<std::string> tones; | |
| tones.push_back("1"); | |
| tones.push_back("a"); | |
| tones.push_back(""); | |
| observer->Verify(tones); | |
| dtmf_sender->UnregisterObserver(); | |
| } | |
| // Verifies that the SessionDescription have rejected the appropriate media | |
| // content. | |
| void VerifyRejectedMediaInSessionDescription() { | |
| ASSERT_TRUE(peer_connection_->remote_description() != nullptr); | |
| ASSERT_TRUE(peer_connection_->local_description() != nullptr); | |
| const cricket::SessionDescription* remote_desc = | |
| peer_connection_->remote_description()->description(); | |
| const cricket::SessionDescription* local_desc = | |
| peer_connection_->local_description()->description(); | |
| const ContentInfo* remote_audio_content = GetFirstAudioContent(remote_desc); | |
| if (remote_audio_content) { | |
| const ContentInfo* audio_content = | |
| GetFirstAudioContent(local_desc); | |
| EXPECT_EQ(can_receive_audio(), !audio_content->rejected); | |
| } | |
| const ContentInfo* remote_video_content = GetFirstVideoContent(remote_desc); | |
| if (remote_video_content) { | |
| const ContentInfo* video_content = | |
| GetFirstVideoContent(local_desc); | |
| EXPECT_EQ(can_receive_video(), !video_content->rejected); | |
| } | |
| } | |
| void VerifyLocalIceUfragAndPassword() { | |
| ASSERT_TRUE(peer_connection_->local_description() != nullptr); | |
| const cricket::SessionDescription* desc = | |
| peer_connection_->local_description()->description(); | |
| const cricket::ContentInfos& contents = desc->contents(); | |
| for (size_t index = 0; index < contents.size(); ++index) { | |
| if (contents[index].rejected) | |
| continue; | |
| const cricket::TransportDescription* transport_desc = | |
| desc->GetTransportDescriptionByName(contents[index].name); | |
| std::map<int, IceUfragPwdPair>::const_iterator ufragpair_it = | |
| ice_ufrag_pwd_.find(static_cast<int>(index)); | |
| if (ufragpair_it == ice_ufrag_pwd_.end()) { | |
| ASSERT_FALSE(ExpectIceRestart()); | |
| ice_ufrag_pwd_[static_cast<int>(index)] = | |
| IceUfragPwdPair(transport_desc->ice_ufrag, transport_desc->ice_pwd); | |
| } else if (ExpectIceRestart()) { | |
| const IceUfragPwdPair& ufrag_pwd = ufragpair_it->second; | |
| EXPECT_NE(ufrag_pwd.first, transport_desc->ice_ufrag); | |
| EXPECT_NE(ufrag_pwd.second, transport_desc->ice_pwd); | |
| } else { | |
| const IceUfragPwdPair& ufrag_pwd = ufragpair_it->second; | |
| EXPECT_EQ(ufrag_pwd.first, transport_desc->ice_ufrag); | |
| EXPECT_EQ(ufrag_pwd.second, transport_desc->ice_pwd); | |
| } | |
| } | |
| } | |
| void VerifyLocalIceRenomination() { | |
| ASSERT_TRUE(peer_connection_->local_description() != nullptr); | |
| const cricket::SessionDescription* desc = | |
| peer_connection_->local_description()->description(); | |
| const cricket::ContentInfos& contents = desc->contents(); | |
| for (auto content : contents) { | |
| if (content.rejected) | |
| continue; | |
| const cricket::TransportDescription* transport_desc = | |
| desc->GetTransportDescriptionByName(content.name); | |
| const auto& options = transport_desc->transport_options; | |
| auto iter = std::find(options.begin(), options.end(), | |
| cricket::ICE_RENOMINATION_STR); | |
| EXPECT_EQ(ExpectIceRenomination(), iter != options.end()); | |
| } | |
| } | |
| void VerifyRemoteIceRenomination() { | |
| ASSERT_TRUE(peer_connection_->remote_description() != nullptr); | |
| const cricket::SessionDescription* desc = | |
| peer_connection_->remote_description()->description(); | |
| const cricket::ContentInfos& contents = desc->contents(); | |
| for (auto content : contents) { | |
| if (content.rejected) | |
| continue; | |
| const cricket::TransportDescription* transport_desc = | |
| desc->GetTransportDescriptionByName(content.name); | |
| const auto& options = transport_desc->transport_options; | |
| auto iter = std::find(options.begin(), options.end(), | |
| cricket::ICE_RENOMINATION_STR); | |
| EXPECT_EQ(ExpectRemoteIceRenomination(), iter != options.end()); | |
| } | |
| } | |
| int GetAudioOutputLevelStats(webrtc::MediaStreamTrackInterface* track) { | |
| rtc::scoped_refptr<MockStatsObserver> | |
| observer(new rtc::RefCountedObject<MockStatsObserver>()); | |
| EXPECT_TRUE(peer_connection_->GetStats( | |
| observer, track, PeerConnectionInterface::kStatsOutputLevelStandard)); | |
| EXPECT_TRUE_WAIT(observer->called(), kMaxWaitMs); | |
| EXPECT_NE(0, observer->timestamp()); | |
| return observer->AudioOutputLevel(); | |
| } | |
| int GetAudioInputLevelStats() { | |
| rtc::scoped_refptr<MockStatsObserver> | |
| observer(new rtc::RefCountedObject<MockStatsObserver>()); | |
| EXPECT_TRUE(peer_connection_->GetStats( | |
| observer, nullptr, PeerConnectionInterface::kStatsOutputLevelStandard)); | |
| EXPECT_TRUE_WAIT(observer->called(), kMaxWaitMs); | |
| EXPECT_NE(0, observer->timestamp()); | |
| return observer->AudioInputLevel(); | |
| } | |
| int GetBytesReceivedStats(webrtc::MediaStreamTrackInterface* track) { | |
| rtc::scoped_refptr<MockStatsObserver> | |
| observer(new rtc::RefCountedObject<MockStatsObserver>()); | |
| EXPECT_TRUE(peer_connection_->GetStats( | |
| observer, track, PeerConnectionInterface::kStatsOutputLevelStandard)); | |
| EXPECT_TRUE_WAIT(observer->called(), kMaxWaitMs); | |
| EXPECT_NE(0, observer->timestamp()); | |
| return observer->BytesReceived(); | |
| } | |
| int GetBytesSentStats(webrtc::MediaStreamTrackInterface* track) { | |
| rtc::scoped_refptr<MockStatsObserver> | |
| observer(new rtc::RefCountedObject<MockStatsObserver>()); | |
| EXPECT_TRUE(peer_connection_->GetStats( | |
| observer, track, PeerConnectionInterface::kStatsOutputLevelStandard)); | |
| EXPECT_TRUE_WAIT(observer->called(), kMaxWaitMs); | |
| EXPECT_NE(0, observer->timestamp()); | |
| return observer->BytesSent(); | |
| } | |
| int GetAvailableReceivedBandwidthStats() { | |
| rtc::scoped_refptr<MockStatsObserver> | |
| observer(new rtc::RefCountedObject<MockStatsObserver>()); | |
| EXPECT_TRUE(peer_connection_->GetStats( | |
| observer, nullptr, PeerConnectionInterface::kStatsOutputLevelStandard)); | |
| EXPECT_TRUE_WAIT(observer->called(), kMaxWaitMs); | |
| EXPECT_NE(0, observer->timestamp()); | |
| int bw = observer->AvailableReceiveBandwidth(); | |
| return bw; | |
| } | |
| std::string GetDtlsCipherStats() { | |
| rtc::scoped_refptr<MockStatsObserver> | |
| observer(new rtc::RefCountedObject<MockStatsObserver>()); | |
| EXPECT_TRUE(peer_connection_->GetStats( | |
| observer, nullptr, PeerConnectionInterface::kStatsOutputLevelStandard)); | |
| EXPECT_TRUE_WAIT(observer->called(), kMaxWaitMs); | |
| EXPECT_NE(0, observer->timestamp()); | |
| return observer->DtlsCipher(); | |
| } | |
| std::string GetSrtpCipherStats() { | |
| rtc::scoped_refptr<MockStatsObserver> | |
| observer(new rtc::RefCountedObject<MockStatsObserver>()); | |
| EXPECT_TRUE(peer_connection_->GetStats( | |
| observer, nullptr, PeerConnectionInterface::kStatsOutputLevelStandard)); | |
| EXPECT_TRUE_WAIT(observer->called(), kMaxWaitMs); | |
| EXPECT_NE(0, observer->timestamp()); | |
| return observer->SrtpCipher(); | |
| } | |
| int rendered_width() { | |
| EXPECT_FALSE(fake_video_renderers_.empty()); | |
| return fake_video_renderers_.empty() ? 1 : | |
| fake_video_renderers_.begin()->second->width(); | |
| } | |
| int rendered_height() { | |
| EXPECT_FALSE(fake_video_renderers_.empty()); | |
| return fake_video_renderers_.empty() ? 1 : | |
| fake_video_renderers_.begin()->second->height(); | |
| } | |
| webrtc::VideoRotation rendered_rotation() { | |
| EXPECT_FALSE(fake_video_renderers_.empty()); | |
| return fake_video_renderers_.empty() | |
| ? webrtc::kVideoRotation_0 | |
| : fake_video_renderers_.begin()->second->rotation(); | |
| } | |
| int local_rendered_width() { | |
| return local_video_renderer_ ? local_video_renderer_->width() : 1; | |
| } | |
| int local_rendered_height() { | |
| return local_video_renderer_ ? local_video_renderer_->height() : 1; | |
| } | |
| size_t number_of_remote_streams() { | |
| if (!pc()) | |
| return 0; | |
| return pc()->remote_streams()->count(); | |
| } | |
| StreamCollectionInterface* remote_streams() const { | |
| if (!pc()) { | |
| ADD_FAILURE(); | |
| return nullptr; | |
| } | |
| return pc()->remote_streams(); | |
| } | |
| StreamCollectionInterface* local_streams() { | |
| if (!pc()) { | |
| ADD_FAILURE(); | |
| return nullptr; | |
| } | |
| return pc()->local_streams(); | |
| } | |
| bool HasLocalAudioTrack() { return StreamsHaveAudioTrack(local_streams()); } | |
| bool HasLocalVideoTrack() { return StreamsHaveVideoTrack(local_streams()); } | |
| webrtc::PeerConnectionInterface::SignalingState signaling_state() { | |
| return pc()->signaling_state(); | |
| } | |
| webrtc::PeerConnectionInterface::IceConnectionState ice_connection_state() { | |
| return pc()->ice_connection_state(); | |
| } | |
| webrtc::PeerConnectionInterface::IceGatheringState ice_gathering_state() { | |
| return pc()->ice_gathering_state(); | |
| } | |
| std::vector<std::unique_ptr<MockRtpReceiverObserver>> const& | |
| rtp_receiver_observers() { | |
| return rtp_receiver_observers_; | |
| } | |
| void SetRtpReceiverObservers() { | |
| rtp_receiver_observers_.clear(); | |
| for (auto receiver : pc()->GetReceivers()) { | |
| std::unique_ptr<MockRtpReceiverObserver> observer( | |
| new MockRtpReceiverObserver(receiver->media_type())); | |
| receiver->SetObserver(observer.get()); | |
| rtp_receiver_observers_.push_back(std::move(observer)); | |
| } | |
| } | |
| private: | |
| class DummyDtmfObserver : public DtmfSenderObserverInterface { | |
| public: | |
| DummyDtmfObserver() : completed_(false) {} | |
| // Implements DtmfSenderObserverInterface. | |
| void OnToneChange(const std::string& tone) override { | |
| tones_.push_back(tone); | |
| if (tone.empty()) { | |
| completed_ = true; | |
| } | |
| } | |
| void Verify(const std::vector<std::string>& tones) const { | |
| ASSERT_TRUE(tones_.size() == tones.size()); | |
| EXPECT_TRUE(std::equal(tones.begin(), tones.end(), tones_.begin())); | |
| } | |
| bool completed() const { return completed_; } | |
| private: | |
| bool completed_; | |
| std::vector<std::string> tones_; | |
| }; | |
| explicit PeerConnectionTestClient(const std::string& id) : id_(id) {} | |
| bool Init( | |
| const MediaConstraintsInterface* constraints, | |
| const PeerConnectionFactory::Options* options, | |
| const PeerConnectionInterface::RTCConfiguration& config, | |
| std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator, | |
| bool prefer_constraint_apis, | |
| rtc::Thread* network_thread, | |
| rtc::Thread* worker_thread) { | |
| EXPECT_TRUE(!peer_connection_); | |
| EXPECT_TRUE(!peer_connection_factory_); | |
| if (!prefer_constraint_apis) { | |
| EXPECT_TRUE(!constraints); | |
| } | |
| prefer_constraint_apis_ = prefer_constraint_apis; | |
| std::unique_ptr<cricket::PortAllocator> port_allocator( | |
| new cricket::FakePortAllocator(network_thread, nullptr)); | |
| fake_audio_capture_module_ = FakeAudioCaptureModule::Create(); | |
| if (fake_audio_capture_module_ == nullptr) { | |
| return false; | |
| } | |
| fake_video_decoder_factory_ = new FakeWebRtcVideoDecoderFactory(); | |
| fake_video_encoder_factory_ = new FakeWebRtcVideoEncoderFactory(); | |
| rtc::Thread* const signaling_thread = rtc::Thread::Current(); | |
| peer_connection_factory_ = webrtc::CreatePeerConnectionFactory( | |
| network_thread, worker_thread, signaling_thread, | |
| fake_audio_capture_module_, fake_video_encoder_factory_, | |
| fake_video_decoder_factory_); | |
| if (!peer_connection_factory_) { | |
| return false; | |
| } | |
| if (options) { | |
| peer_connection_factory_->SetOptions(*options); | |
| } | |
| peer_connection_ = | |
| CreatePeerConnection(std::move(port_allocator), constraints, config, | |
| std::move(cert_generator)); | |
| return peer_connection_.get() != nullptr; | |
| } | |
| rtc::scoped_refptr<webrtc::PeerConnectionInterface> CreatePeerConnection( | |
| std::unique_ptr<cricket::PortAllocator> port_allocator, | |
| const MediaConstraintsInterface* constraints, | |
| const PeerConnectionInterface::RTCConfiguration& config, | |
| std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator) { | |
| return peer_connection_factory_->CreatePeerConnection( | |
| config, constraints, std::move(port_allocator), | |
| std::move(cert_generator), this); | |
| } | |
| void HandleIncomingOffer(const std::string& msg) { | |
| LOG(INFO) << id_ << "HandleIncomingOffer "; | |
| if (NumberOfLocalMediaStreams() == 0 && auto_add_stream_) { | |
| // If we are not sending any streams ourselves it is time to add some. | |
| AddMediaStream(true, true); | |
| } | |
| std::unique_ptr<SessionDescriptionInterface> desc( | |
| webrtc::CreateSessionDescription("offer", msg, nullptr)); | |
| EXPECT_TRUE(DoSetRemoteDescription(desc.release())); | |
| // Set the RtpReceiverObserver after receivers are created. | |
| SetRtpReceiverObservers(); | |
| std::unique_ptr<SessionDescriptionInterface> answer; | |
| EXPECT_TRUE(DoCreateAnswer(&answer)); | |
| std::string sdp; | |
| EXPECT_TRUE(answer->ToString(&sdp)); | |
| EXPECT_TRUE(DoSetLocalDescription(answer.release())); | |
| if (signaling_message_receiver_) { | |
| signaling_message_receiver_->ReceiveSdpMessage( | |
| webrtc::SessionDescriptionInterface::kAnswer, sdp); | |
| } | |
| } | |
| void HandleIncomingAnswer(const std::string& msg) { | |
| LOG(INFO) << id_ << "HandleIncomingAnswer"; | |
| std::unique_ptr<SessionDescriptionInterface> desc( | |
| webrtc::CreateSessionDescription("answer", msg, nullptr)); | |
| EXPECT_TRUE(DoSetRemoteDescription(desc.release())); | |
| // Set the RtpReceiverObserver after receivers are created. | |
| SetRtpReceiverObservers(); | |
| } | |
| bool DoCreateOfferAnswer(std::unique_ptr<SessionDescriptionInterface>* desc, | |
| bool offer) { | |
| rtc::scoped_refptr<MockCreateSessionDescriptionObserver> | |
| observer(new rtc::RefCountedObject< | |
| MockCreateSessionDescriptionObserver>()); | |
| if (prefer_constraint_apis_) { | |
| if (offer) { | |
| pc()->CreateOffer(observer, &offer_answer_constraints_); | |
| } else { | |
| pc()->CreateAnswer(observer, &offer_answer_constraints_); | |
| } | |
| } else { | |
| if (offer) { | |
| pc()->CreateOffer(observer, offer_answer_options_); | |
| } else { | |
| pc()->CreateAnswer(observer, offer_answer_options_); | |
| } | |
| } | |
| EXPECT_EQ_WAIT(true, observer->called(), kMaxWaitMs); | |
| desc->reset(observer->release_desc()); | |
| if (observer->result() && ExpectIceRestart()) { | |
| EXPECT_EQ(0u, (*desc)->candidates(0)->count()); | |
| } | |
| return observer->result(); | |
| } | |
| bool DoCreateOffer(std::unique_ptr<SessionDescriptionInterface>* desc) { | |
| return DoCreateOfferAnswer(desc, true); | |
| } | |
| bool DoCreateAnswer(std::unique_ptr<SessionDescriptionInterface>* desc) { | |
| return DoCreateOfferAnswer(desc, false); | |
| } | |
| bool DoSetLocalDescription(SessionDescriptionInterface* desc) { | |
| rtc::scoped_refptr<MockSetSessionDescriptionObserver> | |
| observer(new rtc::RefCountedObject< | |
| MockSetSessionDescriptionObserver>()); | |
| LOG(INFO) << id_ << "SetLocalDescription "; | |
| pc()->SetLocalDescription(observer, desc); | |
| // Ignore the observer result. If we wait for the result with | |
| // EXPECT_TRUE_WAIT, local ice candidates might be sent to the remote peer | |
| // before the offer which is an error. | |
| // The reason is that EXPECT_TRUE_WAIT uses | |
| // rtc::Thread::Current()->ProcessMessages(1); | |
| // ProcessMessages waits at least 1ms but processes all messages before | |
| // returning. Since this test is synchronous and send messages to the remote | |
| // peer whenever a callback is invoked, this can lead to messages being | |
| // sent to the remote peer in the wrong order. | |
| // TODO(perkj): Find a way to check the result without risking that the | |
| // order of sent messages are changed. Ex- by posting all messages that are | |
| // sent to the remote peer. | |
| return true; | |
| } | |
| bool DoSetRemoteDescription(SessionDescriptionInterface* desc) { | |
| rtc::scoped_refptr<MockSetSessionDescriptionObserver> | |
| observer(new rtc::RefCountedObject< | |
| MockSetSessionDescriptionObserver>()); | |
| LOG(INFO) << id_ << "SetRemoteDescription "; | |
| pc()->SetRemoteDescription(observer, desc); | |
| EXPECT_TRUE_WAIT(observer->called(), kMaxWaitMs); | |
| return observer->result(); | |
| } | |
| // This modifies all received SDP messages before they are processed. | |
| void FilterIncomingSdpMessage(std::string* sdp) { | |
| if (remove_msid_) { | |
| const char kSdpSsrcAttribute[] = "a=ssrc:"; | |
| RemoveLinesFromSdp(kSdpSsrcAttribute, sdp); | |
| const char kSdpMsidSupportedAttribute[] = "a=msid-semantic:"; | |
| RemoveLinesFromSdp(kSdpMsidSupportedAttribute, sdp); | |
| } | |
| if (remove_bundle_) { | |
| const char kSdpBundleAttribute[] = "a=group:BUNDLE"; | |
| RemoveLinesFromSdp(kSdpBundleAttribute, sdp); | |
| } | |
| if (remove_sdes_) { | |
| const char kSdpSdesCryptoAttribute[] = "a=crypto"; | |
| RemoveLinesFromSdp(kSdpSdesCryptoAttribute, sdp); | |
| } | |
| if (remove_cvo_) { | |
| const char kSdpCvoExtenstion[] = "urn:3gpp:video-orientation"; | |
| RemoveLinesFromSdp(kSdpCvoExtenstion, sdp); | |
| } | |
| } | |
| std::string id_; | |
| rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_; | |
| rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> | |
| peer_connection_factory_; | |
| bool prefer_constraint_apis_ = true; | |
| bool auto_add_stream_ = true; | |
| typedef std::pair<std::string, std::string> IceUfragPwdPair; | |
| std::map<int, IceUfragPwdPair> ice_ufrag_pwd_; | |
| bool expect_ice_restart_ = false; | |
| bool expect_ice_renomination_ = false; | |
| bool expect_remote_ice_renomination_ = false; | |
| // Needed to keep track of number of frames sent. | |
| rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_; | |
| // Needed to keep track of number of frames received. | |
| std::map<std::string, std::unique_ptr<webrtc::FakeVideoTrackRenderer>> | |
| fake_video_renderers_; | |
| // Needed to ensure frames aren't received for removed tracks. | |
| std::vector<std::unique_ptr<webrtc::FakeVideoTrackRenderer>> | |
| removed_fake_video_renderers_; | |
| // Needed to keep track of number of frames received when external decoder | |
| // used. | |
| FakeWebRtcVideoDecoderFactory* fake_video_decoder_factory_ = nullptr; | |
| FakeWebRtcVideoEncoderFactory* fake_video_encoder_factory_ = nullptr; | |
| bool video_decoder_factory_enabled_ = false; | |
| webrtc::FakeConstraints video_constraints_; | |
| // For remote peer communication. | |
| SignalingMessageReceiver* signaling_message_receiver_ = nullptr; | |
| // Store references to the video capturers we've created, so that we can stop | |
| // them, if required. | |
| std::vector<cricket::FakeVideoCapturer*> video_capturers_; | |
| webrtc::VideoRotation capture_rotation_ = webrtc::kVideoRotation_0; | |
| // |local_video_renderer_| attached to the first created local video track. | |
| std::unique_ptr<webrtc::FakeVideoTrackRenderer> local_video_renderer_; | |
| webrtc::FakeConstraints offer_answer_constraints_; | |
| PeerConnectionInterface::RTCOfferAnswerOptions offer_answer_options_; | |
| bool remove_msid_ = false; // True if MSID should be removed in received SDP. | |
| bool remove_bundle_ = | |
| false; // True if bundle should be removed in received SDP. | |
| bool remove_sdes_ = | |
| false; // True if a=crypto should be removed in received SDP. | |
| // |remove_cvo_| is true if extension urn:3gpp:video-orientation should be | |
| // removed in the received SDP. | |
| bool remove_cvo_ = false; | |
| rtc::scoped_refptr<DataChannelInterface> data_channel_; | |
| std::unique_ptr<MockDataChannelObserver> data_observer_; | |
| std::vector<std::unique_ptr<MockRtpReceiverObserver>> rtp_receiver_observers_; | |
| }; | |
| class P2PTestConductor : public testing::Test { | |
| public: | |
| P2PTestConductor() | |
| : pss_(new rtc::PhysicalSocketServer), | |
| ss_(new rtc::VirtualSocketServer(pss_.get())), | |
| network_thread_(new rtc::Thread(ss_.get())), | |
| worker_thread_(rtc::Thread::Create()) { | |
| RTC_CHECK(network_thread_->Start()); | |
| RTC_CHECK(worker_thread_->Start()); | |
| webrtc::PeerConnectionInterface::IceServer ice_server; | |
| ice_server.uri = "stun:stun.l.google.com:19302"; | |
| config_.servers.push_back(ice_server); | |
| } | |
| bool SessionActive() { | |
| return initiating_client_->SessionActive() && | |
| receiving_client_->SessionActive(); | |
| } | |
| // Return true if the number of frames provided have been received | |
| // on the video and audio tracks provided. | |
| bool FramesHaveArrived(int audio_frames_to_receive, | |
| int video_frames_to_receive) { | |
| bool all_good = true; | |
| if (initiating_client_->HasLocalAudioTrack() && | |
| receiving_client_->can_receive_audio()) { | |
| all_good &= | |
| receiving_client_->AudioFramesReceivedCheck(audio_frames_to_receive); | |
| } | |
| if (initiating_client_->HasLocalVideoTrack() && | |
| receiving_client_->can_receive_video()) { | |
| all_good &= | |
| receiving_client_->VideoFramesReceivedCheck(video_frames_to_receive); | |
| } | |
| if (receiving_client_->HasLocalAudioTrack() && | |
| initiating_client_->can_receive_audio()) { | |
| all_good &= | |
| initiating_client_->AudioFramesReceivedCheck(audio_frames_to_receive); | |
| } | |
| if (receiving_client_->HasLocalVideoTrack() && | |
| initiating_client_->can_receive_video()) { | |
| all_good &= | |
| initiating_client_->VideoFramesReceivedCheck(video_frames_to_receive); | |
| } | |
| return all_good; | |
| } | |
| void VerifyDtmf() { | |
| initiating_client_->VerifyDtmf(); | |
| receiving_client_->VerifyDtmf(); | |
| } | |
| void TestUpdateOfferWithRejectedContent() { | |
| // Renegotiate, rejecting the video m-line. | |
| initiating_client_->Negotiate(true, false); | |
| ASSERT_TRUE_WAIT(SessionActive(), kMaxWaitForActivationMs); | |
| int pc1_audio_received = initiating_client_->audio_frames_received(); | |
| int pc1_video_received = initiating_client_->video_frames_received(); | |
| int pc2_audio_received = receiving_client_->audio_frames_received(); | |
| int pc2_video_received = receiving_client_->video_frames_received(); | |
| // Wait for some additional audio frames to be received. | |
| EXPECT_TRUE_WAIT(initiating_client_->AudioFramesReceivedCheck( | |
| pc1_audio_received + kEndAudioFrameCount) && | |
| receiving_client_->AudioFramesReceivedCheck( | |
| pc2_audio_received + kEndAudioFrameCount), | |
| kMaxWaitForFramesMs); | |
| // During this time, we shouldn't have received any additional video frames | |
| // for the rejected video tracks. | |
| EXPECT_EQ(pc1_video_received, initiating_client_->video_frames_received()); | |
| EXPECT_EQ(pc2_video_received, receiving_client_->video_frames_received()); | |
| } | |
| void VerifyRenderedSize(int width, int height) { | |
| VerifyRenderedSize(width, height, webrtc::kVideoRotation_0); | |
| } | |
| void VerifyRenderedSize(int width, | |
| int height, | |
| webrtc::VideoRotation rotation) { | |
| EXPECT_EQ(width, receiving_client()->rendered_width()); | |
| EXPECT_EQ(height, receiving_client()->rendered_height()); | |
| EXPECT_EQ(rotation, receiving_client()->rendered_rotation()); | |
| EXPECT_EQ(width, initializing_client()->rendered_width()); | |
| EXPECT_EQ(height, initializing_client()->rendered_height()); | |
| EXPECT_EQ(rotation, initializing_client()->rendered_rotation()); | |
| // Verify size of the local preview. | |
| EXPECT_EQ(width, initializing_client()->local_rendered_width()); | |
| EXPECT_EQ(height, initializing_client()->local_rendered_height()); | |
| } | |
| void VerifySessionDescriptions() { | |
| initiating_client_->VerifyRejectedMediaInSessionDescription(); | |
| receiving_client_->VerifyRejectedMediaInSessionDescription(); | |
| initiating_client_->VerifyLocalIceUfragAndPassword(); | |
| receiving_client_->VerifyLocalIceUfragAndPassword(); | |
| } | |
| ~P2PTestConductor() { | |
| if (initiating_client_) { | |
| initiating_client_->set_signaling_message_receiver(nullptr); | |
| } | |
| if (receiving_client_) { | |
| receiving_client_->set_signaling_message_receiver(nullptr); | |
| } | |
| } | |
| bool CreateTestClients() { return CreateTestClients(nullptr, nullptr); } | |
| bool CreateTestClients(MediaConstraintsInterface* init_constraints, | |
| MediaConstraintsInterface* recv_constraints) { | |
| return CreateTestClients(init_constraints, nullptr, recv_constraints, | |
| nullptr); | |
| } | |
| bool CreateTestClientsThatPreferNoConstraints() { | |
| initiating_client_.reset( | |
| PeerConnectionTestClient::CreateClientPreferNoConstraints( | |
| "Caller: ", nullptr, config_, network_thread_.get(), | |
| worker_thread_.get())); | |
| receiving_client_.reset( | |
| PeerConnectionTestClient::CreateClientPreferNoConstraints( | |
| "Callee: ", nullptr, config_, network_thread_.get(), | |
| worker_thread_.get())); | |
| if (!initiating_client_ || !receiving_client_) { | |
| return false; | |
| } | |
| // Remember the choice for possible later resets of the clients. | |
| prefer_constraint_apis_ = false; | |
| SetSignalingReceivers(); | |
| return true; | |
| } | |
| void SetSignalingReceivers() { | |
| initiating_client_->set_signaling_message_receiver(receiving_client_.get()); | |
| receiving_client_->set_signaling_message_receiver(initiating_client_.get()); | |
| } | |
| bool CreateTestClients(MediaConstraintsInterface* init_constraints, | |
| PeerConnectionFactory::Options* init_options, | |
| MediaConstraintsInterface* recv_constraints, | |
| PeerConnectionFactory::Options* recv_options) { | |
| initiating_client_.reset(PeerConnectionTestClient::CreateClient( | |
| "Caller: ", init_constraints, init_options, config_, | |
| network_thread_.get(), worker_thread_.get())); | |
| receiving_client_.reset(PeerConnectionTestClient::CreateClient( | |
| "Callee: ", recv_constraints, recv_options, config_, | |
| network_thread_.get(), worker_thread_.get())); | |
| if (!initiating_client_ || !receiving_client_) { | |
| return false; | |
| } | |
| SetSignalingReceivers(); | |
| return true; | |
| } | |
| void SetVideoConstraints(const webrtc::FakeConstraints& init_constraints, | |
| const webrtc::FakeConstraints& recv_constraints) { | |
| initiating_client_->SetVideoConstraints(init_constraints); | |
| receiving_client_->SetVideoConstraints(recv_constraints); | |
| } | |
| void SetCaptureRotation(webrtc::VideoRotation rotation) { | |
| initiating_client_->SetCaptureRotation(rotation); | |
| receiving_client_->SetCaptureRotation(rotation); | |
| } | |
| void EnableVideoDecoderFactory() { | |
| initiating_client_->EnableVideoDecoderFactory(); | |
| receiving_client_->EnableVideoDecoderFactory(); | |
| } | |
| // This test sets up a call between two parties. Both parties send static | |
| // frames to each other. Once the test is finished the number of sent frames | |
| // is compared to the number of received frames. | |
| void LocalP2PTest() { | |
| if (initiating_client_->NumberOfLocalMediaStreams() == 0) { | |
| initiating_client_->AddMediaStream(true, true); | |
| } | |
| initiating_client_->Negotiate(); | |
| // Assert true is used here since next tests are guaranteed to fail and | |
| // would eat up 5 seconds. | |
| ASSERT_TRUE_WAIT(SessionActive(), kMaxWaitForActivationMs); | |
| VerifySessionDescriptions(); | |
| int audio_frame_count = kEndAudioFrameCount; | |
| int video_frame_count = kEndVideoFrameCount; | |
| // TODO(ronghuawu): Add test to cover the case of sendonly and recvonly. | |
| if ((!initiating_client_->can_receive_audio() && | |
| !initiating_client_->can_receive_video()) || | |
| (!receiving_client_->can_receive_audio() && | |
| !receiving_client_->can_receive_video())) { | |
| // Neither audio nor video will flow, so connections won't be | |
| // established. There's nothing more to check. | |
| // TODO(hta): Check connection if there's a data channel. | |
| return; | |
| } | |
| // Audio or video is expected to flow, so both clients should reach the | |
| // Connected state, and the offerer (ICE controller) should proceed to | |
| // Completed. | |
| // Note: These tests have been observed to fail under heavy load at | |
| // shorter timeouts, so they may be flaky. | |
| EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted, | |
| initiating_client_->ice_connection_state(), | |
| kMaxWaitForFramesMs); | |
| EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected, | |
| receiving_client_->ice_connection_state(), | |
| kMaxWaitForFramesMs); | |
| // The ICE gathering state should end up in kIceGatheringComplete, | |
| // but there's a bug that prevents this at the moment, and the state | |
| // machine is being updated by the WEBRTC WG. | |
| // TODO(hta): Update this check when spec revisions finish. | |
| EXPECT_NE(webrtc::PeerConnectionInterface::kIceGatheringNew, | |
| initiating_client_->ice_gathering_state()); | |
| EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceGatheringComplete, | |
| receiving_client_->ice_gathering_state(), | |
| kMaxWaitForFramesMs); | |
| // Check that the expected number of frames have arrived. | |
| EXPECT_TRUE_WAIT(FramesHaveArrived(audio_frame_count, video_frame_count), | |
| kMaxWaitForFramesMs); | |
| } | |
| void SetupAndVerifyDtlsCall() { | |
| MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); | |
| FakeConstraints setup_constraints; | |
| setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp, | |
| true); | |
| ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints)); | |
| LocalP2PTest(); | |
| VerifyRenderedSize(640, 480); | |
| } | |
| PeerConnectionTestClient* CreateDtlsClientWithAlternateKey() { | |
| FakeConstraints setup_constraints; | |
| setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp, | |
| true); | |
| std::unique_ptr<FakeRTCCertificateGenerator> cert_generator( | |
| rtc::SSLStreamAdapter::HaveDtlsSrtp() ? | |
| new FakeRTCCertificateGenerator() : nullptr); | |
| cert_generator->use_alternate_key(); | |
| // Make sure the new client is using a different certificate. | |
| return PeerConnectionTestClient::CreateClientWithDtlsIdentityStore( | |
| "New Peer: ", &setup_constraints, nullptr, config_, | |
| std::move(cert_generator), prefer_constraint_apis_, | |
| network_thread_.get(), worker_thread_.get()); | |
| } | |
| void SendRtpData(webrtc::DataChannelInterface* dc, const std::string& data) { | |
| // Messages may get lost on the unreliable DataChannel, so we send multiple | |
| // times to avoid test flakiness. | |
| static const size_t kSendAttempts = 5; | |
| for (size_t i = 0; i < kSendAttempts; ++i) { | |
| dc->Send(DataBuffer(data)); | |
| } | |
| } | |
| rtc::VirtualSocketServer* virtual_socket_server() { return ss_.get(); } | |
| PeerConnectionTestClient* initializing_client() { | |
| return initiating_client_.get(); | |
| } | |
| // Set the |initiating_client_| to the |client| passed in and return the | |
| // original |initiating_client_|. | |
| PeerConnectionTestClient* set_initializing_client( | |
| PeerConnectionTestClient* client) { | |
| PeerConnectionTestClient* old = initiating_client_.release(); | |
| initiating_client_.reset(client); | |
| return old; | |
| } | |
| PeerConnectionTestClient* receiving_client() { | |
| return receiving_client_.get(); | |
| } | |
| // Set the |receiving_client_| to the |client| passed in and return the | |
| // original |receiving_client_|. | |
| PeerConnectionTestClient* set_receiving_client( | |
| PeerConnectionTestClient* client) { | |
| PeerConnectionTestClient* old = receiving_client_.release(); | |
| receiving_client_.reset(client); | |
| return old; | |
| } | |
| webrtc::PeerConnectionInterface::RTCConfiguration* config() { | |
| return &config_; | |
| } | |
| bool AllObserversReceived( | |
| const std::vector<std::unique_ptr<MockRtpReceiverObserver>>& observers) { | |
| for (auto& observer : observers) { | |
| if (!observer->first_packet_received()) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| void TestGcmNegotiation(bool local_gcm_enabled, bool remote_gcm_enabled, | |
| int expected_cipher_suite) { | |
| PeerConnectionFactory::Options init_options; | |
| init_options.crypto_options.enable_gcm_crypto_suites = local_gcm_enabled; | |
| PeerConnectionFactory::Options recv_options; | |
| recv_options.crypto_options.enable_gcm_crypto_suites = remote_gcm_enabled; | |
| ASSERT_TRUE( | |
| CreateTestClients(nullptr, &init_options, nullptr, &recv_options)); | |
| rtc::scoped_refptr<webrtc::FakeMetricsObserver> | |
| init_observer = | |
| new rtc::RefCountedObject<webrtc::FakeMetricsObserver>(); | |
| initializing_client()->pc()->RegisterUMAObserver(init_observer); | |
| LocalP2PTest(); | |
| EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(expected_cipher_suite), | |
| initializing_client()->GetSrtpCipherStats(), | |
| kMaxWaitMs); | |
| EXPECT_EQ(1, | |
| init_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher, | |
| expected_cipher_suite)); | |
| } | |
| private: | |
| // |ss_| is used by |network_thread_| so it must be destroyed later. | |
| std::unique_ptr<rtc::PhysicalSocketServer> pss_; | |
| std::unique_ptr<rtc::VirtualSocketServer> ss_; | |
| // |network_thread_| and |worker_thread_| are used by both | |
| // |initiating_client_| and |receiving_client_| so they must be destroyed | |
| // later. | |
| std::unique_ptr<rtc::Thread> network_thread_; | |
| std::unique_ptr<rtc::Thread> worker_thread_; | |
| std::unique_ptr<PeerConnectionTestClient> initiating_client_; | |
| std::unique_ptr<PeerConnectionTestClient> receiving_client_; | |
| bool prefer_constraint_apis_ = true; | |
| webrtc::PeerConnectionInterface::RTCConfiguration config_; | |
| }; | |
| // Disable for TSan v2, see | |
| // https://code.google.com/p/webrtc/issues/detail?id=1205 for details. | |
| #if !defined(THREAD_SANITIZER) | |
| TEST_F(P2PTestConductor, TestRtpReceiverObserverCallbackFunction) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| LocalP2PTest(); | |
| EXPECT_TRUE_WAIT( | |
| AllObserversReceived(initializing_client()->rtp_receiver_observers()), | |
| kMaxWaitForFramesMs); | |
| EXPECT_TRUE_WAIT( | |
| AllObserversReceived(receiving_client()->rtp_receiver_observers()), | |
| kMaxWaitForFramesMs); | |
| } | |
| // The observers are expected to fire the signal even if they are set after the | |
| // first packet is received. | |
| TEST_F(P2PTestConductor, TestSetRtpReceiverObserverAfterFirstPacketIsReceived) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| LocalP2PTest(); | |
| // Reset the RtpReceiverObservers. | |
| initializing_client()->SetRtpReceiverObservers(); | |
| receiving_client()->SetRtpReceiverObservers(); | |
| EXPECT_TRUE_WAIT( | |
| AllObserversReceived(initializing_client()->rtp_receiver_observers()), | |
| kMaxWaitForFramesMs); | |
| EXPECT_TRUE_WAIT( | |
| AllObserversReceived(receiving_client()->rtp_receiver_observers()), | |
| kMaxWaitForFramesMs); | |
| } | |
| // This test sets up a Jsep call between two parties and test Dtmf. | |
| // TODO(holmer): Disabled due to sometimes crashing on buildbots. | |
| // See issue webrtc/2378. | |
| TEST_F(P2PTestConductor, DISABLED_LocalP2PTestDtmf) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| LocalP2PTest(); | |
| VerifyDtmf(); | |
| } | |
| // This test sets up a Jsep call between two parties and test that we can get a | |
| // video aspect ratio of 16:9. | |
| TEST_F(P2PTestConductor, LocalP2PTest16To9) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| FakeConstraints constraint; | |
| double requested_ratio = 640.0/360; | |
| constraint.SetMandatoryMinAspectRatio(requested_ratio); | |
| SetVideoConstraints(constraint, constraint); | |
| LocalP2PTest(); | |
| ASSERT_LE(0, initializing_client()->rendered_height()); | |
| double initiating_video_ratio = | |
| static_cast<double>(initializing_client()->rendered_width()) / | |
| initializing_client()->rendered_height(); | |
| EXPECT_LE(requested_ratio, initiating_video_ratio); | |
| ASSERT_LE(0, receiving_client()->rendered_height()); | |
| double receiving_video_ratio = | |
| static_cast<double>(receiving_client()->rendered_width()) / | |
| receiving_client()->rendered_height(); | |
| EXPECT_LE(requested_ratio, receiving_video_ratio); | |
| } | |
| // This test sets up a Jsep call between two parties and test that the | |
| // received video has a resolution of 1280*720. | |
| // TODO(mallinath): Enable when | |
| // http://code.google.com/p/webrtc/issues/detail?id=981 is fixed. | |
| TEST_F(P2PTestConductor, DISABLED_LocalP2PTest1280By720) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| FakeConstraints constraint; | |
| constraint.SetMandatoryMinWidth(1280); | |
| constraint.SetMandatoryMinHeight(720); | |
| SetVideoConstraints(constraint, constraint); | |
| LocalP2PTest(); | |
| VerifyRenderedSize(1280, 720); | |
| } | |
| // This test sets up a call between two endpoints that are configured to use | |
| // DTLS key agreement. As a result, DTLS is negotiated and used for transport. | |
| TEST_F(P2PTestConductor, LocalP2PTestDtls) { | |
| SetupAndVerifyDtlsCall(); | |
| } | |
| // This test sets up an one-way call, with media only from initiator to | |
| // responder. | |
| TEST_F(P2PTestConductor, OneWayMediaCall) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| receiving_client()->set_auto_add_stream(false); | |
| LocalP2PTest(); | |
| } | |
| TEST_F(P2PTestConductor, OneWayMediaCallWithoutConstraints) { | |
| ASSERT_TRUE(CreateTestClientsThatPreferNoConstraints()); | |
| receiving_client()->set_auto_add_stream(false); | |
| LocalP2PTest(); | |
| } | |
| // This test sets up a audio call initially and then upgrades to audio/video, | |
| // using DTLS. | |
| TEST_F(P2PTestConductor, LocalP2PTestDtlsRenegotiate) { | |
| MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); | |
| FakeConstraints setup_constraints; | |
| setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp, | |
| true); | |
| ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints)); | |
| receiving_client()->SetReceiveAudioVideo(true, false); | |
| LocalP2PTest(); | |
| receiving_client()->SetReceiveAudioVideo(true, true); | |
| receiving_client()->Negotiate(); | |
| } | |
| // This test sets up a call transfer to a new caller with a different DTLS | |
| // fingerprint. | |
| TEST_F(P2PTestConductor, LocalP2PTestDtlsTransferCallee) { | |
| MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); | |
| SetupAndVerifyDtlsCall(); | |
| // Keeping the original peer around which will still send packets to the | |
| // receiving client. These SRTP packets will be dropped. | |
| std::unique_ptr<PeerConnectionTestClient> original_peer( | |
| set_initializing_client(CreateDtlsClientWithAlternateKey())); | |
| original_peer->pc()->Close(); | |
| SetSignalingReceivers(); | |
| receiving_client()->SetExpectIceRestart(true); | |
| LocalP2PTest(); | |
| VerifyRenderedSize(640, 480); | |
| } | |
| // This test sets up a non-bundle call and apply bundle during ICE restart. When | |
| // bundle is in effect in the restart, the channel can successfully reset its | |
| // DTLS-SRTP context. | |
| TEST_F(P2PTestConductor, LocalP2PTestDtlsBundleInIceRestart) { | |
| MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); | |
| FakeConstraints setup_constraints; | |
| setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp, | |
| true); | |
| ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints)); | |
| receiving_client()->RemoveBundleFromReceivedSdp(true); | |
| LocalP2PTest(); | |
| VerifyRenderedSize(640, 480); | |
| initializing_client()->IceRestart(); | |
| receiving_client()->SetExpectIceRestart(true); | |
| receiving_client()->RemoveBundleFromReceivedSdp(false); | |
| LocalP2PTest(); | |
| VerifyRenderedSize(640, 480); | |
| } | |
| // This test sets up a call transfer to a new callee with a different DTLS | |
| // fingerprint. | |
| TEST_F(P2PTestConductor, LocalP2PTestDtlsTransferCaller) { | |
| MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); | |
| SetupAndVerifyDtlsCall(); | |
| // Keeping the original peer around which will still send packets to the | |
| // receiving client. These SRTP packets will be dropped. | |
| std::unique_ptr<PeerConnectionTestClient> original_peer( | |
| set_receiving_client(CreateDtlsClientWithAlternateKey())); | |
| original_peer->pc()->Close(); | |
| SetSignalingReceivers(); | |
| initializing_client()->IceRestart(); | |
| LocalP2PTest(); | |
| VerifyRenderedSize(640, 480); | |
| } | |
| TEST_F(P2PTestConductor, LocalP2PTestCVO) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| SetCaptureRotation(webrtc::kVideoRotation_90); | |
| LocalP2PTest(); | |
| VerifyRenderedSize(640, 480, webrtc::kVideoRotation_90); | |
| } | |
| TEST_F(P2PTestConductor, LocalP2PTestReceiverDoesntSupportCVO) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| SetCaptureRotation(webrtc::kVideoRotation_90); | |
| receiving_client()->RemoveCvoFromReceivedSdp(true); | |
| LocalP2PTest(); | |
| VerifyRenderedSize(480, 640, webrtc::kVideoRotation_0); | |
| } | |
| // This test sets up a call between two endpoints that are configured to use | |
| // DTLS key agreement. The offerer don't support SDES. As a result, DTLS is | |
| // negotiated and used for transport. | |
| TEST_F(P2PTestConductor, LocalP2PTestOfferDtlsButNotSdes) { | |
| MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); | |
| FakeConstraints setup_constraints; | |
| setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp, | |
| true); | |
| ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints)); | |
| receiving_client()->RemoveSdesCryptoFromReceivedSdp(true); | |
| LocalP2PTest(); | |
| VerifyRenderedSize(640, 480); | |
| } | |
| // This test sets up a Jsep call between two parties, and the callee only | |
| // accept to receive video. | |
| TEST_F(P2PTestConductor, LocalP2PTestAnswerVideo) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| receiving_client()->SetReceiveAudioVideo(false, true); | |
| LocalP2PTest(); | |
| } | |
| // This test sets up a Jsep call between two parties, and the callee only | |
| // accept to receive audio. | |
| TEST_F(P2PTestConductor, LocalP2PTestAnswerAudio) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| receiving_client()->SetReceiveAudioVideo(true, false); | |
| LocalP2PTest(); | |
| } | |
| // This test sets up a Jsep call between two parties, and the callee reject both | |
| // audio and video. | |
| TEST_F(P2PTestConductor, LocalP2PTestAnswerNone) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| receiving_client()->SetReceiveAudioVideo(false, false); | |
| LocalP2PTest(); | |
| } | |
| // This test sets up an audio and video call between two parties. After the call | |
| // runs for a while (10 frames), the caller sends an update offer with video | |
| // being rejected. Once the re-negotiation is done, the video flow should stop | |
| // and the audio flow should continue. | |
| TEST_F(P2PTestConductor, UpdateOfferWithRejectedContent) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| LocalP2PTest(); | |
| TestUpdateOfferWithRejectedContent(); | |
| } | |
| // This test sets up a Jsep call between two parties. The MSID is removed from | |
| // the SDP strings from the caller. | |
| TEST_F(P2PTestConductor, LocalP2PTestWithoutMsid) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| receiving_client()->RemoveMsidFromReceivedSdp(true); | |
| // TODO(perkj): Currently there is a bug that cause audio to stop playing if | |
| // audio and video is muxed when MSID is disabled. Remove | |
| // SetRemoveBundleFromSdp once | |
| // https://code.google.com/p/webrtc/issues/detail?id=1193 is fixed. | |
| receiving_client()->RemoveBundleFromReceivedSdp(true); | |
| LocalP2PTest(); | |
| } | |
| // This test sets up a Jsep call between two parties and the initiating peer | |
| // sends two steams. | |
| // TODO(perkj): Disabled due to | |
| // https://code.google.com/p/webrtc/issues/detail?id=1454 | |
| TEST_F(P2PTestConductor, DISABLED_LocalP2PTestTwoStreams) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| // Set optional video constraint to max 320pixels to decrease CPU usage. | |
| FakeConstraints constraint; | |
| constraint.SetOptionalMaxWidth(320); | |
| SetVideoConstraints(constraint, constraint); | |
| initializing_client()->AddMediaStream(true, true); | |
| initializing_client()->AddMediaStream(false, true); | |
| ASSERT_EQ(2u, initializing_client()->NumberOfLocalMediaStreams()); | |
| LocalP2PTest(); | |
| EXPECT_EQ(2u, receiving_client()->number_of_remote_streams()); | |
| } | |
| // Test that we can receive the audio output level from a remote audio track. | |
| TEST_F(P2PTestConductor, GetAudioOutputLevelStats) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| LocalP2PTest(); | |
| StreamCollectionInterface* remote_streams = | |
| initializing_client()->remote_streams(); | |
| ASSERT_GT(remote_streams->count(), 0u); | |
| ASSERT_GT(remote_streams->at(0)->GetAudioTracks().size(), 0u); | |
| MediaStreamTrackInterface* remote_audio_track = | |
| remote_streams->at(0)->GetAudioTracks()[0]; | |
| // Get the audio output level stats. Note that the level is not available | |
| // until a RTCP packet has been received. | |
| EXPECT_TRUE_WAIT( | |
| initializing_client()->GetAudioOutputLevelStats(remote_audio_track) > 0, | |
| kMaxWaitForStatsMs); | |
| } | |
| // Test that an audio input level is reported. | |
| TEST_F(P2PTestConductor, GetAudioInputLevelStats) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| LocalP2PTest(); | |
| // Get the audio input level stats. The level should be available very | |
| // soon after the test starts. | |
| EXPECT_TRUE_WAIT(initializing_client()->GetAudioInputLevelStats() > 0, | |
| kMaxWaitForStatsMs); | |
| } | |
| // Test that we can get incoming byte counts from both audio and video tracks. | |
| TEST_F(P2PTestConductor, GetBytesReceivedStats) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| LocalP2PTest(); | |
| StreamCollectionInterface* remote_streams = | |
| initializing_client()->remote_streams(); | |
| ASSERT_GT(remote_streams->count(), 0u); | |
| ASSERT_GT(remote_streams->at(0)->GetAudioTracks().size(), 0u); | |
| MediaStreamTrackInterface* remote_audio_track = | |
| remote_streams->at(0)->GetAudioTracks()[0]; | |
| EXPECT_TRUE_WAIT( | |
| initializing_client()->GetBytesReceivedStats(remote_audio_track) > 0, | |
| kMaxWaitForStatsMs); | |
| MediaStreamTrackInterface* remote_video_track = | |
| remote_streams->at(0)->GetVideoTracks()[0]; | |
| EXPECT_TRUE_WAIT( | |
| initializing_client()->GetBytesReceivedStats(remote_video_track) > 0, | |
| kMaxWaitForStatsMs); | |
| } | |
| // Test that we can get outgoing byte counts from both audio and video tracks. | |
| TEST_F(P2PTestConductor, GetBytesSentStats) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| LocalP2PTest(); | |
| StreamCollectionInterface* local_streams = | |
| initializing_client()->local_streams(); | |
| ASSERT_GT(local_streams->count(), 0u); | |
| ASSERT_GT(local_streams->at(0)->GetAudioTracks().size(), 0u); | |
| MediaStreamTrackInterface* local_audio_track = | |
| local_streams->at(0)->GetAudioTracks()[0]; | |
| EXPECT_TRUE_WAIT( | |
| initializing_client()->GetBytesSentStats(local_audio_track) > 0, | |
| kMaxWaitForStatsMs); | |
| MediaStreamTrackInterface* local_video_track = | |
| local_streams->at(0)->GetVideoTracks()[0]; | |
| EXPECT_TRUE_WAIT( | |
| initializing_client()->GetBytesSentStats(local_video_track) > 0, | |
| kMaxWaitForStatsMs); | |
| } | |
| // Test that DTLS 1.0 is used if both sides only support DTLS 1.0. | |
| TEST_F(P2PTestConductor, GetDtls12None) { | |
| PeerConnectionFactory::Options init_options; | |
| init_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_10; | |
| PeerConnectionFactory::Options recv_options; | |
| recv_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_10; | |
| ASSERT_TRUE( | |
| CreateTestClients(nullptr, &init_options, nullptr, &recv_options)); | |
| rtc::scoped_refptr<webrtc::FakeMetricsObserver> | |
| init_observer = new rtc::RefCountedObject<webrtc::FakeMetricsObserver>(); | |
| initializing_client()->pc()->RegisterUMAObserver(init_observer); | |
| LocalP2PTest(); | |
| EXPECT_TRUE_WAIT( | |
| rtc::SSLStreamAdapter::IsAcceptableCipher( | |
| initializing_client()->GetDtlsCipherStats(), rtc::KT_DEFAULT), | |
| kMaxWaitForStatsMs); | |
| EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(kDefaultSrtpCryptoSuite), | |
| initializing_client()->GetSrtpCipherStats(), | |
| kMaxWaitForStatsMs); | |
| EXPECT_EQ(1, | |
| init_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher, | |
| kDefaultSrtpCryptoSuite)); | |
| } | |
| // Test that DTLS 1.2 is used if both ends support it. | |
| TEST_F(P2PTestConductor, GetDtls12Both) { | |
| PeerConnectionFactory::Options init_options; | |
| init_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12; | |
| PeerConnectionFactory::Options recv_options; | |
| recv_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12; | |
| ASSERT_TRUE( | |
| CreateTestClients(nullptr, &init_options, nullptr, &recv_options)); | |
| rtc::scoped_refptr<webrtc::FakeMetricsObserver> | |
| init_observer = new rtc::RefCountedObject<webrtc::FakeMetricsObserver>(); | |
| initializing_client()->pc()->RegisterUMAObserver(init_observer); | |
| LocalP2PTest(); | |
| EXPECT_TRUE_WAIT( | |
| rtc::SSLStreamAdapter::IsAcceptableCipher( | |
| initializing_client()->GetDtlsCipherStats(), rtc::KT_DEFAULT), | |
| kMaxWaitForStatsMs); | |
| EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(kDefaultSrtpCryptoSuite), | |
| initializing_client()->GetSrtpCipherStats(), | |
| kMaxWaitForStatsMs); | |
| EXPECT_EQ(1, | |
| init_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher, | |
| kDefaultSrtpCryptoSuite)); | |
| } | |
| // Test that DTLS 1.0 is used if the initator supports DTLS 1.2 and the | |
| // received supports 1.0. | |
| TEST_F(P2PTestConductor, GetDtls12Init) { | |
| PeerConnectionFactory::Options init_options; | |
| init_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12; | |
| PeerConnectionFactory::Options recv_options; | |
| recv_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_10; | |
| ASSERT_TRUE( | |
| CreateTestClients(nullptr, &init_options, nullptr, &recv_options)); | |
| rtc::scoped_refptr<webrtc::FakeMetricsObserver> | |
| init_observer = new rtc::RefCountedObject<webrtc::FakeMetricsObserver>(); | |
| initializing_client()->pc()->RegisterUMAObserver(init_observer); | |
| LocalP2PTest(); | |
| EXPECT_TRUE_WAIT( | |
| rtc::SSLStreamAdapter::IsAcceptableCipher( | |
| initializing_client()->GetDtlsCipherStats(), rtc::KT_DEFAULT), | |
| kMaxWaitForStatsMs); | |
| EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(kDefaultSrtpCryptoSuite), | |
| initializing_client()->GetSrtpCipherStats(), | |
| kMaxWaitForStatsMs); | |
| EXPECT_EQ(1, | |
| init_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher, | |
| kDefaultSrtpCryptoSuite)); | |
| } | |
| // Test that DTLS 1.0 is used if the initator supports DTLS 1.0 and the | |
| // received supports 1.2. | |
| TEST_F(P2PTestConductor, GetDtls12Recv) { | |
| PeerConnectionFactory::Options init_options; | |
| init_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_10; | |
| PeerConnectionFactory::Options recv_options; | |
| recv_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12; | |
| ASSERT_TRUE( | |
| CreateTestClients(nullptr, &init_options, nullptr, &recv_options)); | |
| rtc::scoped_refptr<webrtc::FakeMetricsObserver> | |
| init_observer = new rtc::RefCountedObject<webrtc::FakeMetricsObserver>(); | |
| initializing_client()->pc()->RegisterUMAObserver(init_observer); | |
| LocalP2PTest(); | |
| EXPECT_TRUE_WAIT( | |
| rtc::SSLStreamAdapter::IsAcceptableCipher( | |
| initializing_client()->GetDtlsCipherStats(), rtc::KT_DEFAULT), | |
| kMaxWaitForStatsMs); | |
| EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(kDefaultSrtpCryptoSuite), | |
| initializing_client()->GetSrtpCipherStats(), | |
| kMaxWaitForStatsMs); | |
| EXPECT_EQ(1, | |
| init_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher, | |
| kDefaultSrtpCryptoSuite)); | |
| } | |
| // Test that a non-GCM cipher is used if both sides only support non-GCM. | |
| TEST_F(P2PTestConductor, GetGcmNone) { | |
| TestGcmNegotiation(false, false, kDefaultSrtpCryptoSuite); | |
| } | |
| // Test that a GCM cipher is used if both ends support it. | |
| TEST_F(P2PTestConductor, GetGcmBoth) { | |
| TestGcmNegotiation(true, true, kDefaultSrtpCryptoSuiteGcm); | |
| } | |
| // Test that GCM isn't used if only the initiator supports it. | |
| TEST_F(P2PTestConductor, GetGcmInit) { | |
| TestGcmNegotiation(true, false, kDefaultSrtpCryptoSuite); | |
| } | |
| // Test that GCM isn't used if only the receiver supports it. | |
| TEST_F(P2PTestConductor, GetGcmRecv) { | |
| TestGcmNegotiation(false, true, kDefaultSrtpCryptoSuite); | |
| } | |
| // This test sets up a call between two parties with audio, video and an RTP | |
| // data channel. | |
| TEST_F(P2PTestConductor, LocalP2PTestRtpDataChannel) { | |
| FakeConstraints setup_constraints; | |
| setup_constraints.SetAllowRtpDataChannels(); | |
| ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints)); | |
| initializing_client()->CreateDataChannel(); | |
| LocalP2PTest(); | |
| ASSERT_TRUE(initializing_client()->data_channel() != nullptr); | |
| ASSERT_TRUE(receiving_client()->data_channel() != nullptr); | |
| EXPECT_TRUE_WAIT(initializing_client()->data_observer()->IsOpen(), | |
| kMaxWaitMs); | |
| EXPECT_TRUE_WAIT(receiving_client()->data_observer()->IsOpen(), | |
| kMaxWaitMs); | |
| std::string data = "hello world"; | |
| SendRtpData(initializing_client()->data_channel(), data); | |
| EXPECT_EQ_WAIT(data, receiving_client()->data_observer()->last_message(), | |
| kMaxWaitMs); | |
| SendRtpData(receiving_client()->data_channel(), data); | |
| EXPECT_EQ_WAIT(data, initializing_client()->data_observer()->last_message(), | |
| kMaxWaitMs); | |
| receiving_client()->data_channel()->Close(); | |
| // Send new offer and answer. | |
| receiving_client()->Negotiate(); | |
| EXPECT_FALSE(initializing_client()->data_observer()->IsOpen()); | |
| EXPECT_FALSE(receiving_client()->data_observer()->IsOpen()); | |
| } | |
| // This test sets up a call between two parties with audio, video and an SCTP | |
| // data channel. | |
| TEST_F(P2PTestConductor, LocalP2PTestSctpDataChannel) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| initializing_client()->CreateDataChannel(); | |
| LocalP2PTest(); | |
| ASSERT_TRUE(initializing_client()->data_channel() != nullptr); | |
| EXPECT_TRUE_WAIT(receiving_client()->data_channel() != nullptr, kMaxWaitMs); | |
| EXPECT_TRUE_WAIT(initializing_client()->data_observer()->IsOpen(), | |
| kMaxWaitMs); | |
| EXPECT_TRUE_WAIT(receiving_client()->data_observer()->IsOpen(), kMaxWaitMs); | |
| std::string data = "hello world"; | |
| initializing_client()->data_channel()->Send(DataBuffer(data)); | |
| EXPECT_EQ_WAIT(data, receiving_client()->data_observer()->last_message(), | |
| kMaxWaitMs); | |
| receiving_client()->data_channel()->Send(DataBuffer(data)); | |
| EXPECT_EQ_WAIT(data, initializing_client()->data_observer()->last_message(), | |
| kMaxWaitMs); | |
| receiving_client()->data_channel()->Close(); | |
| EXPECT_TRUE_WAIT(!initializing_client()->data_observer()->IsOpen(), | |
| kMaxWaitMs); | |
| EXPECT_TRUE_WAIT(!receiving_client()->data_observer()->IsOpen(), kMaxWaitMs); | |
| } | |
| TEST_F(P2PTestConductor, UnorderedSctpDataChannel) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| webrtc::DataChannelInit init; | |
| init.ordered = false; | |
| initializing_client()->CreateDataChannel(&init); | |
| // Introduce random network delays. | |
| // Otherwise it's not a true "unordered" test. | |
| virtual_socket_server()->set_delay_mean(20); | |
| virtual_socket_server()->set_delay_stddev(5); | |
| virtual_socket_server()->UpdateDelayDistribution(); | |
| initializing_client()->Negotiate(); | |
| ASSERT_TRUE(initializing_client()->data_channel() != nullptr); | |
| EXPECT_TRUE_WAIT(receiving_client()->data_channel() != nullptr, kMaxWaitMs); | |
| EXPECT_TRUE_WAIT(initializing_client()->data_observer()->IsOpen(), | |
| kMaxWaitMs); | |
| EXPECT_TRUE_WAIT(receiving_client()->data_observer()->IsOpen(), kMaxWaitMs); | |
| static constexpr int kNumMessages = 100; | |
| // Deliberately chosen to be larger than the MTU so messages get fragmented. | |
| static constexpr size_t kMaxMessageSize = 4096; | |
| // Create and send random messages. | |
| std::vector<std::string> sent_messages; | |
| for (int i = 0; i < kNumMessages; ++i) { | |
| size_t length = (rand() % kMaxMessageSize) + 1; | |
| std::string message; | |
| ASSERT_TRUE(rtc::CreateRandomString(length, &message)); | |
| initializing_client()->data_channel()->Send(DataBuffer(message)); | |
| receiving_client()->data_channel()->Send(DataBuffer(message)); | |
| sent_messages.push_back(message); | |
| } | |
| EXPECT_EQ_WAIT( | |
| kNumMessages, | |
| initializing_client()->data_observer()->received_message_count(), | |
| kMaxWaitMs); | |
| EXPECT_EQ_WAIT(kNumMessages, | |
| receiving_client()->data_observer()->received_message_count(), | |
| kMaxWaitMs); | |
| // Sort and compare to make sure none of the messages were corrupted. | |
| std::vector<std::string> initializing_client_received_messages = | |
| initializing_client()->data_observer()->messages(); | |
| std::vector<std::string> receiving_client_received_messages = | |
| receiving_client()->data_observer()->messages(); | |
| std::sort(sent_messages.begin(), sent_messages.end()); | |
| std::sort(initializing_client_received_messages.begin(), | |
| initializing_client_received_messages.end()); | |
| std::sort(receiving_client_received_messages.begin(), | |
| receiving_client_received_messages.end()); | |
| EXPECT_EQ(sent_messages, initializing_client_received_messages); | |
| EXPECT_EQ(sent_messages, receiving_client_received_messages); | |
| receiving_client()->data_channel()->Close(); | |
| EXPECT_TRUE_WAIT(!initializing_client()->data_observer()->IsOpen(), | |
| kMaxWaitMs); | |
| EXPECT_TRUE_WAIT(!receiving_client()->data_observer()->IsOpen(), kMaxWaitMs); | |
| } | |
| // This test sets up a call between two parties and creates a data channel. | |
| // The test tests that received data is buffered unless an observer has been | |
| // registered. | |
| // Rtp data channels can receive data before the underlying | |
| // transport has detected that a channel is writable and thus data can be | |
| // received before the data channel state changes to open. That is hard to test | |
| // but the same buffering is used in that case. | |
| TEST_F(P2PTestConductor, RegisterDataChannelObserver) { | |
| FakeConstraints setup_constraints; | |
| setup_constraints.SetAllowRtpDataChannels(); | |
| ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints)); | |
| initializing_client()->CreateDataChannel(); | |
| initializing_client()->Negotiate(); | |
| ASSERT_TRUE(initializing_client()->data_channel() != nullptr); | |
| ASSERT_TRUE(receiving_client()->data_channel() != nullptr); | |
| EXPECT_TRUE_WAIT(initializing_client()->data_observer()->IsOpen(), | |
| kMaxWaitMs); | |
| EXPECT_EQ_WAIT(DataChannelInterface::kOpen, | |
| receiving_client()->data_channel()->state(), kMaxWaitMs); | |
| // Unregister the existing observer. | |
| receiving_client()->data_channel()->UnregisterObserver(); | |
| std::string data = "hello world"; | |
| SendRtpData(initializing_client()->data_channel(), data); | |
| // Wait a while to allow the sent data to arrive before an observer is | |
| // registered.. | |
| rtc::Thread::Current()->ProcessMessages(100); | |
| MockDataChannelObserver new_observer(receiving_client()->data_channel()); | |
| EXPECT_EQ_WAIT(data, new_observer.last_message(), kMaxWaitMs); | |
| } | |
| // This test sets up a call between two parties with audio, video and but only | |
| // the initiating client support data. | |
| TEST_F(P2PTestConductor, LocalP2PTestReceiverDoesntSupportData) { | |
| FakeConstraints setup_constraints_1; | |
| setup_constraints_1.SetAllowRtpDataChannels(); | |
| // Must disable DTLS to make negotiation succeed. | |
| setup_constraints_1.SetMandatory( | |
| MediaConstraintsInterface::kEnableDtlsSrtp, false); | |
| FakeConstraints setup_constraints_2; | |
| setup_constraints_2.SetMandatory( | |
| MediaConstraintsInterface::kEnableDtlsSrtp, false); | |
| ASSERT_TRUE(CreateTestClients(&setup_constraints_1, &setup_constraints_2)); | |
| initializing_client()->CreateDataChannel(); | |
| LocalP2PTest(); | |
| EXPECT_TRUE(initializing_client()->data_channel() != nullptr); | |
| EXPECT_FALSE(receiving_client()->data_channel()); | |
| EXPECT_FALSE(initializing_client()->data_observer()->IsOpen()); | |
| } | |
| // This test sets up a call between two parties with audio, video. When audio | |
| // and video is setup and flowing and data channel is negotiated. | |
| TEST_F(P2PTestConductor, AddDataChannelAfterRenegotiation) { | |
| FakeConstraints setup_constraints; | |
| setup_constraints.SetAllowRtpDataChannels(); | |
| ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints)); | |
| LocalP2PTest(); | |
| initializing_client()->CreateDataChannel(); | |
| // Send new offer and answer. | |
| initializing_client()->Negotiate(); | |
| ASSERT_TRUE(initializing_client()->data_channel() != nullptr); | |
| ASSERT_TRUE(receiving_client()->data_channel() != nullptr); | |
| EXPECT_TRUE_WAIT(initializing_client()->data_observer()->IsOpen(), | |
| kMaxWaitMs); | |
| EXPECT_TRUE_WAIT(receiving_client()->data_observer()->IsOpen(), | |
| kMaxWaitMs); | |
| } | |
| // This test sets up a Jsep call with SCTP DataChannel and verifies the | |
| // negotiation is completed without error. | |
| #ifdef HAVE_SCTP | |
| TEST_F(P2PTestConductor, CreateOfferWithSctpDataChannel) { | |
| MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); | |
| FakeConstraints constraints; | |
| constraints.SetMandatory( | |
| MediaConstraintsInterface::kEnableDtlsSrtp, true); | |
| ASSERT_TRUE(CreateTestClients(&constraints, &constraints)); | |
| initializing_client()->CreateDataChannel(); | |
| initializing_client()->Negotiate(false, false); | |
| } | |
| #endif | |
| // This test sets up a call between two parties with audio, and video. | |
| // During the call, the initializing side restart ice and the test verifies that | |
| // new ice candidates are generated and audio and video still can flow. | |
| TEST_F(P2PTestConductor, IceRestart) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| // Negotiate and wait for ice completion and make sure audio and video plays. | |
| LocalP2PTest(); | |
| // Create a SDP string of the first audio candidate for both clients. | |
| const webrtc::IceCandidateCollection* audio_candidates_initiator = | |
| initializing_client()->pc()->local_description()->candidates(0); | |
| const webrtc::IceCandidateCollection* audio_candidates_receiver = | |
| receiving_client()->pc()->local_description()->candidates(0); | |
| ASSERT_GT(audio_candidates_initiator->count(), 0u); | |
| ASSERT_GT(audio_candidates_receiver->count(), 0u); | |
| std::string initiator_candidate; | |
| EXPECT_TRUE( | |
| audio_candidates_initiator->at(0)->ToString(&initiator_candidate)); | |
| std::string receiver_candidate; | |
| EXPECT_TRUE(audio_candidates_receiver->at(0)->ToString(&receiver_candidate)); | |
| // Restart ice on the initializing client. | |
| receiving_client()->SetExpectIceRestart(true); | |
| initializing_client()->IceRestart(); | |
| // Negotiate and wait for ice completion again and make sure audio and video | |
| // plays. | |
| LocalP2PTest(); | |
| // Create a SDP string of the first audio candidate for both clients again. | |
| const webrtc::IceCandidateCollection* audio_candidates_initiator_restart = | |
| initializing_client()->pc()->local_description()->candidates(0); | |
| const webrtc::IceCandidateCollection* audio_candidates_reciever_restart = | |
| receiving_client()->pc()->local_description()->candidates(0); | |
| ASSERT_GT(audio_candidates_initiator_restart->count(), 0u); | |
| ASSERT_GT(audio_candidates_reciever_restart->count(), 0u); | |
| std::string initiator_candidate_restart; | |
| EXPECT_TRUE(audio_candidates_initiator_restart->at(0)->ToString( | |
| &initiator_candidate_restart)); | |
| std::string receiver_candidate_restart; | |
| EXPECT_TRUE(audio_candidates_reciever_restart->at(0)->ToString( | |
| &receiver_candidate_restart)); | |
| // Verify that the first candidates in the local session descriptions has | |
| // changed. | |
| EXPECT_NE(initiator_candidate, initiator_candidate_restart); | |
| EXPECT_NE(receiver_candidate, receiver_candidate_restart); | |
| } | |
| TEST_F(P2PTestConductor, IceRenominationDisabled) { | |
| config()->enable_ice_renomination = false; | |
| ASSERT_TRUE(CreateTestClients()); | |
| LocalP2PTest(); | |
| initializing_client()->VerifyLocalIceRenomination(); | |
| receiving_client()->VerifyLocalIceRenomination(); | |
| initializing_client()->VerifyRemoteIceRenomination(); | |
| receiving_client()->VerifyRemoteIceRenomination(); | |
| } | |
| TEST_F(P2PTestConductor, IceRenominationEnabled) { | |
| config()->enable_ice_renomination = true; | |
| ASSERT_TRUE(CreateTestClients()); | |
| initializing_client()->SetExpectIceRenomination(true); | |
| initializing_client()->SetExpectRemoteIceRenomination(true); | |
| receiving_client()->SetExpectIceRenomination(true); | |
| receiving_client()->SetExpectRemoteIceRenomination(true); | |
| LocalP2PTest(); | |
| initializing_client()->VerifyLocalIceRenomination(); | |
| receiving_client()->VerifyLocalIceRenomination(); | |
| initializing_client()->VerifyRemoteIceRenomination(); | |
| receiving_client()->VerifyRemoteIceRenomination(); | |
| } | |
| // This test sets up a call between two parties with audio, and video. | |
| // It then renegotiates setting the video m-line to "port 0", then later | |
| // renegotiates again, enabling video. | |
| TEST_F(P2PTestConductor, LocalP2PTestVideoDisableEnable) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| // Do initial negotiation. Will result in video and audio sendonly m-lines. | |
| receiving_client()->set_auto_add_stream(false); | |
| initializing_client()->AddMediaStream(true, true); | |
| initializing_client()->Negotiate(); | |
| // Negotiate again, disabling the video m-line (receiving client will | |
| // set port to 0 due to mandatory "OfferToReceiveVideo: false" constraint). | |
| receiving_client()->SetReceiveVideo(false); | |
| initializing_client()->Negotiate(); | |
| // Enable video and do negotiation again, making sure video is received | |
| // end-to-end. | |
| receiving_client()->SetReceiveVideo(true); | |
| receiving_client()->AddMediaStream(true, true); | |
| LocalP2PTest(); | |
| } | |
| // This test sets up a Jsep call between two parties with external | |
| // VideoDecoderFactory. | |
| // TODO(holmer): Disabled due to sometimes crashing on buildbots. | |
| // See issue webrtc/2378. | |
| TEST_F(P2PTestConductor, DISABLED_LocalP2PTestWithVideoDecoderFactory) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| EnableVideoDecoderFactory(); | |
| LocalP2PTest(); | |
| } | |
| // This tests that if we negotiate after calling CreateSender but before we | |
| // have a track, then set a track later, frames from the newly-set track are | |
| // received end-to-end. | |
| TEST_F(P2PTestConductor, EarlyWarmupTest) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| auto audio_sender = | |
| initializing_client()->pc()->CreateSender("audio", "stream_id"); | |
| auto video_sender = | |
| initializing_client()->pc()->CreateSender("video", "stream_id"); | |
| initializing_client()->Negotiate(); | |
| // Wait for ICE connection to complete, without any tracks. | |
| // Note that the receiving client WILL (in HandleIncomingOffer) create | |
| // tracks, so it's only the initiator here that's doing early warmup. | |
| ASSERT_TRUE_WAIT(SessionActive(), kMaxWaitForActivationMs); | |
| VerifySessionDescriptions(); | |
| EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted, | |
| initializing_client()->ice_connection_state(), | |
| kMaxWaitForFramesMs); | |
| EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected, | |
| receiving_client()->ice_connection_state(), | |
| kMaxWaitForFramesMs); | |
| // Now set the tracks, and expect frames to immediately start flowing. | |
| EXPECT_TRUE( | |
| audio_sender->SetTrack(initializing_client()->CreateLocalAudioTrack(""))); | |
| EXPECT_TRUE( | |
| video_sender->SetTrack(initializing_client()->CreateLocalVideoTrack(""))); | |
| EXPECT_TRUE_WAIT(FramesHaveArrived(kEndAudioFrameCount, kEndVideoFrameCount), | |
| kMaxWaitForFramesMs); | |
| } | |
| #ifdef HAVE_QUIC | |
| // This test sets up a call between two parties using QUIC instead of DTLS for | |
| // audio and video, and a QUIC data channel. | |
| TEST_F(P2PTestConductor, LocalP2PTestQuicDataChannel) { | |
| config()->enable_quic = true; | |
| ASSERT_TRUE(CreateTestClients()); | |
| webrtc::DataChannelInit init; | |
| init.ordered = false; | |
| init.reliable = true; | |
| init.id = 1; | |
| initializing_client()->CreateDataChannel(&init); | |
| receiving_client()->CreateDataChannel(&init); | |
| LocalP2PTest(); | |
| ASSERT_NE(nullptr, initializing_client()->data_channel()); | |
| ASSERT_NE(nullptr, receiving_client()->data_channel()); | |
| EXPECT_TRUE_WAIT(initializing_client()->data_observer()->IsOpen(), | |
| kMaxWaitMs); | |
| EXPECT_TRUE_WAIT(receiving_client()->data_observer()->IsOpen(), kMaxWaitMs); | |
| std::string data = "hello world"; | |
| initializing_client()->data_channel()->Send(DataBuffer(data)); | |
| EXPECT_EQ_WAIT(data, receiving_client()->data_observer()->last_message(), | |
| kMaxWaitMs); | |
| receiving_client()->data_channel()->Send(DataBuffer(data)); | |
| EXPECT_EQ_WAIT(data, initializing_client()->data_observer()->last_message(), | |
| kMaxWaitMs); | |
| } | |
| // Tests that negotiation of QUIC data channels is completed without error. | |
| TEST_F(P2PTestConductor, NegotiateQuicDataChannel) { | |
| config()->enable_quic = true; | |
| FakeConstraints constraints; | |
| constraints.SetMandatory(MediaConstraintsInterface::kEnableDtlsSrtp, true); | |
| ASSERT_TRUE(CreateTestClients(&constraints, &constraints)); | |
| webrtc::DataChannelInit init; | |
| init.ordered = false; | |
| init.reliable = true; | |
| init.id = 1; | |
| initializing_client()->CreateDataChannel(&init); | |
| initializing_client()->Negotiate(false, false); | |
| } | |
| // This test sets up a JSEP call using QUIC. The callee only receives video. | |
| TEST_F(P2PTestConductor, LocalP2PTestVideoOnlyWithQuic) { | |
| config()->enable_quic = true; | |
| ASSERT_TRUE(CreateTestClients()); | |
| receiving_client()->SetReceiveAudioVideo(false, true); | |
| LocalP2PTest(); | |
| } | |
| // This test sets up a JSEP call using QUIC. The callee only receives audio. | |
| TEST_F(P2PTestConductor, LocalP2PTestAudioOnlyWithQuic) { | |
| config()->enable_quic = true; | |
| ASSERT_TRUE(CreateTestClients()); | |
| receiving_client()->SetReceiveAudioVideo(true, false); | |
| LocalP2PTest(); | |
| } | |
| // This test sets up a JSEP call using QUIC. The callee rejects both audio and | |
| // video. | |
| TEST_F(P2PTestConductor, LocalP2PTestNoVideoAudioWithQuic) { | |
| config()->enable_quic = true; | |
| ASSERT_TRUE(CreateTestClients()); | |
| receiving_client()->SetReceiveAudioVideo(false, false); | |
| LocalP2PTest(); | |
| } | |
| #endif // HAVE_QUIC | |
| TEST_F(P2PTestConductor, ForwardVideoOnlyStream) { | |
| ASSERT_TRUE(CreateTestClients()); | |
| // One-way stream | |
| receiving_client()->set_auto_add_stream(false); | |
| // Video only, audio forwarding not expected to work. | |
| initializing_client()->AddMediaStream(false, true); | |
| initializing_client()->Negotiate(); | |
| ASSERT_TRUE_WAIT(SessionActive(), kMaxWaitForActivationMs); | |
| VerifySessionDescriptions(); | |
| ASSERT_TRUE(initializing_client()->can_receive_video()); | |
| ASSERT_TRUE(receiving_client()->can_receive_video()); | |
| EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted, | |
| initializing_client()->ice_connection_state(), | |
| kMaxWaitForFramesMs); | |
| EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected, | |
| receiving_client()->ice_connection_state(), | |
| kMaxWaitForFramesMs); | |
| ASSERT_TRUE(receiving_client()->remote_streams()->count() == 1); | |
| // Echo the stream back. | |
| receiving_client()->pc()->AddStream( | |
| receiving_client()->remote_streams()->at(0)); | |
| receiving_client()->Negotiate(); | |
| EXPECT_TRUE_WAIT( | |
| initializing_client()->VideoFramesReceivedCheck(kEndVideoFrameCount), | |
| kMaxWaitForFramesMs); | |
| } | |
| class IceServerParsingTest : public testing::Test { | |
| public: | |
| // Convenience for parsing a single URL. | |
| bool ParseUrl(const std::string& url) { | |
| return ParseUrl(url, std::string(), std::string()); | |
| } | |
| bool ParseUrl(const std::string& url, | |
| const std::string& username, | |
| const std::string& password) { | |
| PeerConnectionInterface::IceServers servers; | |
| PeerConnectionInterface::IceServer server; | |
| server.urls.push_back(url); | |
| server.username = username; | |
| server.password = password; | |
| servers.push_back(server); | |
| return webrtc::ParseIceServers(servers, &stun_servers_, &turn_servers_); | |
| } | |
| protected: | |
| cricket::ServerAddresses stun_servers_; | |
| std::vector<cricket::RelayServerConfig> turn_servers_; | |
| }; | |
| // Make sure all STUN/TURN prefixes are parsed correctly. | |
| TEST_F(IceServerParsingTest, ParseStunPrefixes) { | |
| EXPECT_TRUE(ParseUrl("stun:hostname")); | |
| EXPECT_EQ(1U, stun_servers_.size()); | |
| EXPECT_EQ(0U, turn_servers_.size()); | |
| stun_servers_.clear(); | |
| EXPECT_TRUE(ParseUrl("stuns:hostname")); | |
| EXPECT_EQ(1U, stun_servers_.size()); | |
| EXPECT_EQ(0U, turn_servers_.size()); | |
| stun_servers_.clear(); | |
| EXPECT_TRUE(ParseUrl("turn:hostname")); | |
| EXPECT_EQ(0U, stun_servers_.size()); | |
| EXPECT_EQ(1U, turn_servers_.size()); | |
| EXPECT_FALSE(turn_servers_[0].ports[0].secure); | |
| turn_servers_.clear(); | |
| EXPECT_TRUE(ParseUrl("turns:hostname")); | |
| EXPECT_EQ(0U, stun_servers_.size()); | |
| EXPECT_EQ(1U, turn_servers_.size()); | |
| EXPECT_TRUE(turn_servers_[0].ports[0].secure); | |
| turn_servers_.clear(); | |
| // invalid prefixes | |
| EXPECT_FALSE(ParseUrl("stunn:hostname")); | |
| EXPECT_FALSE(ParseUrl(":hostname")); | |
| EXPECT_FALSE(ParseUrl(":")); | |
| EXPECT_FALSE(ParseUrl("")); | |
| } | |
| TEST_F(IceServerParsingTest, VerifyDefaults) { | |
| // TURNS defaults | |
| EXPECT_TRUE(ParseUrl("turns:hostname")); | |
| EXPECT_EQ(1U, turn_servers_.size()); | |
| EXPECT_EQ(5349, turn_servers_[0].ports[0].address.port()); | |
| EXPECT_EQ(cricket::PROTO_TCP, turn_servers_[0].ports[0].proto); | |
| turn_servers_.clear(); | |
| // TURN defaults | |
| EXPECT_TRUE(ParseUrl("turn:hostname")); | |
| EXPECT_EQ(1U, turn_servers_.size()); | |
| EXPECT_EQ(3478, turn_servers_[0].ports[0].address.port()); | |
| EXPECT_EQ(cricket::PROTO_UDP, turn_servers_[0].ports[0].proto); | |
| turn_servers_.clear(); | |
| // STUN defaults | |
| EXPECT_TRUE(ParseUrl("stun:hostname")); | |
| EXPECT_EQ(1U, stun_servers_.size()); | |
| EXPECT_EQ(3478, stun_servers_.begin()->port()); | |
| stun_servers_.clear(); | |
| } | |
| // Check that the 6 combinations of IPv4/IPv6/hostname and with/without port | |
| // can be parsed correctly. | |
| TEST_F(IceServerParsingTest, ParseHostnameAndPort) { | |
| EXPECT_TRUE(ParseUrl("stun:1.2.3.4:1234")); | |
| EXPECT_EQ(1U, stun_servers_.size()); | |
| EXPECT_EQ("1.2.3.4", stun_servers_.begin()->hostname()); | |
| EXPECT_EQ(1234, stun_servers_.begin()->port()); | |
| stun_servers_.clear(); | |
| EXPECT_TRUE(ParseUrl("stun:[1:2:3:4:5:6:7:8]:4321")); | |
| EXPECT_EQ(1U, stun_servers_.size()); | |
| EXPECT_EQ("1:2:3:4:5:6:7:8", stun_servers_.begin()->hostname()); | |
| EXPECT_EQ(4321, stun_servers_.begin()->port()); | |
| stun_servers_.clear(); | |
| EXPECT_TRUE(ParseUrl("stun:hostname:9999")); | |
| EXPECT_EQ(1U, stun_servers_.size()); | |
| EXPECT_EQ("hostname", stun_servers_.begin()->hostname()); | |
| EXPECT_EQ(9999, stun_servers_.begin()->port()); | |
| stun_servers_.clear(); | |
| EXPECT_TRUE(ParseUrl("stun:1.2.3.4")); | |
| EXPECT_EQ(1U, stun_servers_.size()); | |
| EXPECT_EQ("1.2.3.4", stun_servers_.begin()->hostname()); | |
| EXPECT_EQ(3478, stun_servers_.begin()->port()); | |
| stun_servers_.clear(); | |
| EXPECT_TRUE(ParseUrl("stun:[1:2:3:4:5:6:7:8]")); | |
| EXPECT_EQ(1U, stun_servers_.size()); | |
| EXPECT_EQ("1:2:3:4:5:6:7:8", stun_servers_.begin()->hostname()); | |
| EXPECT_EQ(3478, stun_servers_.begin()->port()); | |
| stun_servers_.clear(); | |
| EXPECT_TRUE(ParseUrl("stun:hostname")); | |
| EXPECT_EQ(1U, stun_servers_.size()); | |
| EXPECT_EQ("hostname", stun_servers_.begin()->hostname()); | |
| EXPECT_EQ(3478, stun_servers_.begin()->port()); | |
| stun_servers_.clear(); | |
| // Try some invalid hostname:port strings. | |
| EXPECT_FALSE(ParseUrl("stun:hostname:99a99")); | |
| EXPECT_FALSE(ParseUrl("stun:hostname:-1")); | |
| EXPECT_FALSE(ParseUrl("stun:hostname:port:more")); | |
| EXPECT_FALSE(ParseUrl("stun:hostname:port more")); | |
| EXPECT_FALSE(ParseUrl("stun:hostname:")); | |
| EXPECT_FALSE(ParseUrl("stun:[1:2:3:4:5:6:7:8]junk:1000")); | |
| EXPECT_FALSE(ParseUrl("stun::5555")); | |
| EXPECT_FALSE(ParseUrl("stun:")); | |
| } | |
| // Test parsing the "?transport=xxx" part of the URL. | |
| TEST_F(IceServerParsingTest, ParseTransport) { | |
| EXPECT_TRUE(ParseUrl("turn:hostname:1234?transport=tcp")); | |
| EXPECT_EQ(1U, turn_servers_.size()); | |
| EXPECT_EQ(cricket::PROTO_TCP, turn_servers_[0].ports[0].proto); | |
| turn_servers_.clear(); | |
| EXPECT_TRUE(ParseUrl("turn:hostname?transport=udp")); | |
| EXPECT_EQ(1U, turn_servers_.size()); | |
| EXPECT_EQ(cricket::PROTO_UDP, turn_servers_[0].ports[0].proto); | |
| turn_servers_.clear(); | |
| EXPECT_FALSE(ParseUrl("turn:hostname?transport=invalid")); | |
| } | |
| // Test parsing ICE username contained in URL. | |
| TEST_F(IceServerParsingTest, ParseUsername) { | |
| EXPECT_TRUE(ParseUrl("turn:user@hostname")); | |
| EXPECT_EQ(1U, turn_servers_.size()); | |
| EXPECT_EQ("user", turn_servers_[0].credentials.username); | |
| turn_servers_.clear(); | |
| EXPECT_FALSE(ParseUrl("turn:@hostname")); | |
| EXPECT_FALSE(ParseUrl("turn:username@")); | |
| EXPECT_FALSE(ParseUrl("turn:@")); | |
| EXPECT_FALSE(ParseUrl("turn:user@name@hostname")); | |
| } | |
| // Test that username and password from IceServer is copied into the resulting | |
| // RelayServerConfig. | |
| TEST_F(IceServerParsingTest, CopyUsernameAndPasswordFromIceServer) { | |
| EXPECT_TRUE(ParseUrl("turn:hostname", "username", "password")); | |
| EXPECT_EQ(1U, turn_servers_.size()); | |
| EXPECT_EQ("username", turn_servers_[0].credentials.username); | |
| EXPECT_EQ("password", turn_servers_[0].credentials.password); | |
| } | |
| // Ensure that if a server has multiple URLs, each one is parsed. | |
| TEST_F(IceServerParsingTest, ParseMultipleUrls) { | |
| PeerConnectionInterface::IceServers servers; | |
| PeerConnectionInterface::IceServer server; | |
| server.urls.push_back("stun:hostname"); | |
| server.urls.push_back("turn:hostname"); | |
| servers.push_back(server); | |
| EXPECT_TRUE(webrtc::ParseIceServers(servers, &stun_servers_, &turn_servers_)); | |
| EXPECT_EQ(1U, stun_servers_.size()); | |
| EXPECT_EQ(1U, turn_servers_.size()); | |
| } | |
| // Ensure that TURN servers are given unique priorities, | |
| // so that their resulting candidates have unique priorities. | |
| TEST_F(IceServerParsingTest, TurnServerPrioritiesUnique) { | |
| PeerConnectionInterface::IceServers servers; | |
| PeerConnectionInterface::IceServer server; | |
| server.urls.push_back("turn:hostname"); | |
| server.urls.push_back("turn:hostname2"); | |
| servers.push_back(server); | |
| EXPECT_TRUE(webrtc::ParseIceServers(servers, &stun_servers_, &turn_servers_)); | |
| EXPECT_EQ(2U, turn_servers_.size()); | |
| EXPECT_NE(turn_servers_[0].priority, turn_servers_[1].priority); | |
| } | |
| #endif // if !defined(THREAD_SANITIZER) | |
| } // namespace |