Index: webrtc/api/peerconnectioninterface_unittest.cc |
diff --git a/webrtc/api/peerconnectioninterface_unittest.cc b/webrtc/api/peerconnectioninterface_unittest.cc |
deleted file mode 100644 |
index be3825ce0fab0b89dc90f04e1ac87a8d95f8698e..0000000000000000000000000000000000000000 |
--- a/webrtc/api/peerconnectioninterface_unittest.cc |
+++ /dev/null |
@@ -1,3412 +0,0 @@ |
-/* |
- * 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 <memory> |
-#include <sstream> |
-#include <string> |
-#include <utility> |
- |
-#include "webrtc/api/audiotrack.h" |
-#include "webrtc/api/jsepsessiondescription.h" |
-#include "webrtc/api/mediastream.h" |
-#include "webrtc/api/mediastreaminterface.h" |
-#include "webrtc/api/peerconnection.h" |
-#include "webrtc/api/peerconnectioninterface.h" |
-#include "webrtc/api/rtpreceiverinterface.h" |
-#include "webrtc/api/rtpsenderinterface.h" |
-#include "webrtc/api/streamcollection.h" |
-#include "webrtc/api/test/fakeconstraints.h" |
-#include "webrtc/api/test/fakertccertificategenerator.h" |
-#include "webrtc/api/test/fakevideotracksource.h" |
-#include "webrtc/api/test/mockpeerconnectionobservers.h" |
-#include "webrtc/api/test/testsdpstrings.h" |
-#include "webrtc/api/videocapturertracksource.h" |
-#include "webrtc/api/videotrack.h" |
-#include "webrtc/base/gunit.h" |
-#include "webrtc/base/ssladapter.h" |
-#include "webrtc/base/sslstreamadapter.h" |
-#include "webrtc/base/stringutils.h" |
-#include "webrtc/base/thread.h" |
-#include "webrtc/media/base/fakevideocapturer.h" |
-#include "webrtc/media/sctp/sctptransportinternal.h" |
-#include "webrtc/p2p/base/fakeportallocator.h" |
-#include "webrtc/p2p/base/faketransportcontroller.h" |
-#include "webrtc/pc/mediasession.h" |
-#include "webrtc/test/gmock.h" |
- |
-#ifdef WEBRTC_ANDROID |
-#include "webrtc/api/test/androidtestinitializer.h" |
-#endif |
- |
-static const char kStreamLabel1[] = "local_stream_1"; |
-static const char kStreamLabel2[] = "local_stream_2"; |
-static const char kStreamLabel3[] = "local_stream_3"; |
-static const int kDefaultStunPort = 3478; |
-static const char kStunAddressOnly[] = "stun:address"; |
-static const char kStunInvalidPort[] = "stun:address:-1"; |
-static const char kStunAddressPortAndMore1[] = "stun:address:port:more"; |
-static const char kStunAddressPortAndMore2[] = "stun:address:port more"; |
-static const char kTurnIceServerUri[] = "turn:user@turn.example.org"; |
-static const char kTurnUsername[] = "user"; |
-static const char kTurnPassword[] = "password"; |
-static const char kTurnHostname[] = "turn.example.org"; |
-static const uint32_t kTimeout = 10000U; |
- |
-static const char kStreams[][8] = {"stream1", "stream2"}; |
-static const char kAudioTracks[][32] = {"audiotrack0", "audiotrack1"}; |
-static const char kVideoTracks[][32] = {"videotrack0", "videotrack1"}; |
- |
-static const char kRecvonly[] = "recvonly"; |
-static const char kSendrecv[] = "sendrecv"; |
- |
-// Reference SDP with a MediaStream with label "stream1" and audio track with |
-// id "audio_1" and a video track with id "video_1; |
-static const char kSdpStringWithStream1[] = |
- "v=0\r\n" |
- "o=- 0 0 IN IP4 127.0.0.1\r\n" |
- "s=-\r\n" |
- "t=0 0\r\n" |
- "m=audio 1 RTP/AVPF 103\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:" |
- "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n" |
- "a=mid:audio\r\n" |
- "a=sendrecv\r\n" |
- "a=rtcp-mux\r\n" |
- "a=rtpmap:103 ISAC/16000\r\n" |
- "a=ssrc:1 cname:stream1\r\n" |
- "a=ssrc:1 mslabel:stream1\r\n" |
- "a=ssrc:1 label:audiotrack0\r\n" |
- "m=video 1 RTP/AVPF 120\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:" |
- "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n" |
- "a=mid:video\r\n" |
- "a=sendrecv\r\n" |
- "a=rtcp-mux\r\n" |
- "a=rtpmap:120 VP8/90000\r\n" |
- "a=ssrc:2 cname:stream1\r\n" |
- "a=ssrc:2 mslabel:stream1\r\n" |
- "a=ssrc:2 label:videotrack0\r\n"; |
- |
-// Reference SDP with a MediaStream with label "stream1" and audio track with |
-// id "audio_1"; |
-static const char kSdpStringWithStream1AudioTrackOnly[] = |
- "v=0\r\n" |
- "o=- 0 0 IN IP4 127.0.0.1\r\n" |
- "s=-\r\n" |
- "t=0 0\r\n" |
- "m=audio 1 RTP/AVPF 103\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:" |
- "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n" |
- "a=mid:audio\r\n" |
- "a=sendrecv\r\n" |
- "a=rtpmap:103 ISAC/16000\r\n" |
- "a=ssrc:1 cname:stream1\r\n" |
- "a=ssrc:1 mslabel:stream1\r\n" |
- "a=ssrc:1 label:audiotrack0\r\n" |
- "a=rtcp-mux\r\n"; |
- |
-// Reference SDP with two MediaStreams with label "stream1" and "stream2. Each |
-// MediaStreams have one audio track and one video track. |
-// This uses MSID. |
-static const char kSdpStringWithStream1And2[] = |
- "v=0\r\n" |
- "o=- 0 0 IN IP4 127.0.0.1\r\n" |
- "s=-\r\n" |
- "t=0 0\r\n" |
- "a=msid-semantic: WMS stream1 stream2\r\n" |
- "m=audio 1 RTP/AVPF 103\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:" |
- "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n" |
- "a=mid:audio\r\n" |
- "a=sendrecv\r\n" |
- "a=rtcp-mux\r\n" |
- "a=rtpmap:103 ISAC/16000\r\n" |
- "a=ssrc:1 cname:stream1\r\n" |
- "a=ssrc:1 msid:stream1 audiotrack0\r\n" |
- "a=ssrc:3 cname:stream2\r\n" |
- "a=ssrc:3 msid:stream2 audiotrack1\r\n" |
- "m=video 1 RTP/AVPF 120\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:" |
- "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n" |
- "a=mid:video\r\n" |
- "a=sendrecv\r\n" |
- "a=rtcp-mux\r\n" |
- "a=rtpmap:120 VP8/0\r\n" |
- "a=ssrc:2 cname:stream1\r\n" |
- "a=ssrc:2 msid:stream1 videotrack0\r\n" |
- "a=ssrc:4 cname:stream2\r\n" |
- "a=ssrc:4 msid:stream2 videotrack1\r\n"; |
- |
-// Reference SDP without MediaStreams. Msid is not supported. |
-static const char kSdpStringWithoutStreams[] = |
- "v=0\r\n" |
- "o=- 0 0 IN IP4 127.0.0.1\r\n" |
- "s=-\r\n" |
- "t=0 0\r\n" |
- "m=audio 1 RTP/AVPF 103\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:" |
- "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n" |
- "a=mid:audio\r\n" |
- "a=sendrecv\r\n" |
- "a=rtcp-mux\r\n" |
- "a=rtpmap:103 ISAC/16000\r\n" |
- "m=video 1 RTP/AVPF 120\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:" |
- "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n" |
- "a=mid:video\r\n" |
- "a=sendrecv\r\n" |
- "a=rtcp-mux\r\n" |
- "a=rtpmap:120 VP8/90000\r\n"; |
- |
-// Reference SDP without MediaStreams. Msid is supported. |
-static const char kSdpStringWithMsidWithoutStreams[] = |
- "v=0\r\n" |
- "o=- 0 0 IN IP4 127.0.0.1\r\n" |
- "s=-\r\n" |
- "t=0 0\r\n" |
- "a=msid-semantic: WMS\r\n" |
- "m=audio 1 RTP/AVPF 103\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:" |
- "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n" |
- "a=mid:audio\r\n" |
- "a=sendrecv\r\n" |
- "a=rtcp-mux\r\n" |
- "a=rtpmap:103 ISAC/16000\r\n" |
- "m=video 1 RTP/AVPF 120\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:" |
- "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n" |
- "a=mid:video\r\n" |
- "a=sendrecv\r\n" |
- "a=rtcp-mux\r\n" |
- "a=rtpmap:120 VP8/90000\r\n"; |
- |
-// Reference SDP without MediaStreams and audio only. |
-static const char kSdpStringWithoutStreamsAudioOnly[] = |
- "v=0\r\n" |
- "o=- 0 0 IN IP4 127.0.0.1\r\n" |
- "s=-\r\n" |
- "t=0 0\r\n" |
- "m=audio 1 RTP/AVPF 103\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:" |
- "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n" |
- "a=mid:audio\r\n" |
- "a=sendrecv\r\n" |
- "a=rtcp-mux\r\n" |
- "a=rtpmap:103 ISAC/16000\r\n"; |
- |
-// Reference SENDONLY SDP without MediaStreams. Msid is not supported. |
-static const char kSdpStringSendOnlyWithoutStreams[] = |
- "v=0\r\n" |
- "o=- 0 0 IN IP4 127.0.0.1\r\n" |
- "s=-\r\n" |
- "t=0 0\r\n" |
- "m=audio 1 RTP/AVPF 103\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:" |
- "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n" |
- "a=mid:audio\r\n" |
- "a=sendrecv\r\n" |
- "a=sendonly\r\n" |
- "a=rtcp-mux\r\n" |
- "a=rtpmap:103 ISAC/16000\r\n" |
- "m=video 1 RTP/AVPF 120\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:" |
- "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n" |
- "a=mid:video\r\n" |
- "a=sendrecv\r\n" |
- "a=sendonly\r\n" |
- "a=rtcp-mux\r\n" |
- "a=rtpmap:120 VP8/90000\r\n"; |
- |
-static const char kSdpStringInit[] = |
- "v=0\r\n" |
- "o=- 0 0 IN IP4 127.0.0.1\r\n" |
- "s=-\r\n" |
- "t=0 0\r\n" |
- "a=msid-semantic: WMS\r\n"; |
- |
-static const char kSdpStringAudio[] = |
- "m=audio 1 RTP/AVPF 103\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:" |
- "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n" |
- "a=mid:audio\r\n" |
- "a=sendrecv\r\n" |
- "a=rtcp-mux\r\n" |
- "a=rtpmap:103 ISAC/16000\r\n"; |
- |
-static const char kSdpStringVideo[] = |
- "m=video 1 RTP/AVPF 120\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:" |
- "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n" |
- "a=mid:video\r\n" |
- "a=sendrecv\r\n" |
- "a=rtcp-mux\r\n" |
- "a=rtpmap:120 VP8/90000\r\n"; |
- |
-static const char kSdpStringMs1Audio0[] = |
- "a=ssrc:1 cname:stream1\r\n" |
- "a=ssrc:1 msid:stream1 audiotrack0\r\n"; |
- |
-static const char kSdpStringMs1Video0[] = |
- "a=ssrc:2 cname:stream1\r\n" |
- "a=ssrc:2 msid:stream1 videotrack0\r\n"; |
- |
-static const char kSdpStringMs1Audio1[] = |
- "a=ssrc:3 cname:stream1\r\n" |
- "a=ssrc:3 msid:stream1 audiotrack1\r\n"; |
- |
-static const char kSdpStringMs1Video1[] = |
- "a=ssrc:4 cname:stream1\r\n" |
- "a=ssrc:4 msid:stream1 videotrack1\r\n"; |
- |
-static const char kDtlsSdesFallbackSdp[] = |
- "v=0\r\n" |
- "o=xxxxxx 7 2 IN IP4 0.0.0.0\r\n" |
- "s=-\r\n" |
- "c=IN IP4 0.0.0.0\r\n" |
- "t=0 0\r\n" |
- "a=group:BUNDLE audio\r\n" |
- "a=msid-semantic: WMS\r\n" |
- "m=audio 1 RTP/SAVPF 0\r\n" |
- "a=sendrecv\r\n" |
- "a=rtcp-mux\r\n" |
- "a=mid:audio\r\n" |
- "a=ssrc:1 cname:stream1\r\n" |
- "a=ssrc:1 mslabel:stream1\r\n" |
- "a=ssrc:1 label:audiotrack0\r\n" |
- "a=ice-ufrag:e5785931\r\n" |
- "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n" |
- "a=rtpmap:0 pcmu/8000\r\n" |
- "a=fingerprint:sha-1 " |
- "4A:AD:B9:B1:3F:82:18:3B:54:02:12:DF:3E:5D:49:6B:19:E5:7C:AB\r\n" |
- "a=setup:actpass\r\n" |
- "a=crypto:1 AES_CM_128_HMAC_SHA1_32 " |
- "inline:NzB4d1BINUAvLEw6UzF3WSJ+PSdFcGdUJShpX1Zj|2^20|1:32 " |
- "dummy_session_params\r\n"; |
- |
-#define MAYBE_SKIP_TEST(feature) \ |
- if (!(feature())) { \ |
- LOG(LS_INFO) << "Feature disabled... skipping"; \ |
- return; \ |
- } |
- |
-using ::testing::Exactly; |
-using cricket::StreamParams; |
-using webrtc::AudioSourceInterface; |
-using webrtc::AudioTrack; |
-using webrtc::AudioTrackInterface; |
-using webrtc::DataBuffer; |
-using webrtc::DataChannelInterface; |
-using webrtc::FakeConstraints; |
-using webrtc::IceCandidateInterface; |
-using webrtc::JsepSessionDescription; |
-using webrtc::MediaConstraintsInterface; |
-using webrtc::MediaStream; |
-using webrtc::MediaStreamInterface; |
-using webrtc::MediaStreamTrackInterface; |
-using webrtc::MockCreateSessionDescriptionObserver; |
-using webrtc::MockDataChannelObserver; |
-using webrtc::MockSetSessionDescriptionObserver; |
-using webrtc::MockStatsObserver; |
-using webrtc::NotifierInterface; |
-using webrtc::ObserverInterface; |
-using webrtc::PeerConnectionInterface; |
-using webrtc::PeerConnectionObserver; |
-using webrtc::RTCError; |
-using webrtc::RTCErrorType; |
-using webrtc::RtpReceiverInterface; |
-using webrtc::RtpSenderInterface; |
-using webrtc::SdpParseError; |
-using webrtc::SessionDescriptionInterface; |
-using webrtc::StreamCollection; |
-using webrtc::StreamCollectionInterface; |
-using webrtc::VideoTrackSourceInterface; |
-using webrtc::VideoTrack; |
-using webrtc::VideoTrackInterface; |
- |
-typedef PeerConnectionInterface::RTCOfferAnswerOptions RTCOfferAnswerOptions; |
- |
-namespace { |
- |
-// Gets the first ssrc of given content type from the ContentInfo. |
-bool GetFirstSsrc(const cricket::ContentInfo* content_info, int* ssrc) { |
- if (!content_info || !ssrc) { |
- return false; |
- } |
- const cricket::MediaContentDescription* media_desc = |
- static_cast<const cricket::MediaContentDescription*>( |
- content_info->description); |
- if (!media_desc || media_desc->streams().empty()) { |
- return false; |
- } |
- *ssrc = media_desc->streams().begin()->first_ssrc(); |
- return true; |
-} |
- |
-// Get the ufrags out of an SDP blob. Useful for testing ICE restart |
-// behavior. |
-std::vector<std::string> GetUfrags( |
- const webrtc::SessionDescriptionInterface* desc) { |
- std::vector<std::string> ufrags; |
- for (const cricket::TransportInfo& info : |
- desc->description()->transport_infos()) { |
- ufrags.push_back(info.description.ice_ufrag); |
- } |
- return ufrags; |
-} |
- |
-void SetSsrcToZero(std::string* sdp) { |
- const char kSdpSsrcAtribute[] = "a=ssrc:"; |
- const char kSdpSsrcAtributeZero[] = "a=ssrc:0"; |
- size_t ssrc_pos = 0; |
- while ((ssrc_pos = sdp->find(kSdpSsrcAtribute, ssrc_pos)) != |
- std::string::npos) { |
- size_t end_ssrc = sdp->find(" ", ssrc_pos); |
- sdp->replace(ssrc_pos, end_ssrc - ssrc_pos, kSdpSsrcAtributeZero); |
- ssrc_pos = end_ssrc; |
- } |
-} |
- |
-// Check if |streams| contains the specified track. |
-bool ContainsTrack(const std::vector<cricket::StreamParams>& streams, |
- const std::string& stream_label, |
- const std::string& track_id) { |
- for (const cricket::StreamParams& params : streams) { |
- if (params.sync_label == stream_label && params.id == track_id) { |
- return true; |
- } |
- } |
- return false; |
-} |
- |
-// Check if |senders| contains the specified sender, by id. |
-bool ContainsSender( |
- const std::vector<rtc::scoped_refptr<RtpSenderInterface>>& senders, |
- const std::string& id) { |
- for (const auto& sender : senders) { |
- if (sender->id() == id) { |
- return true; |
- } |
- } |
- return false; |
-} |
- |
-// Check if |senders| contains the specified sender, by id and stream id. |
-bool ContainsSender( |
- const std::vector<rtc::scoped_refptr<RtpSenderInterface>>& senders, |
- const std::string& id, |
- const std::string& stream_id) { |
- for (const auto& sender : senders) { |
- if (sender->id() == id && sender->stream_ids()[0] == stream_id) { |
- return true; |
- } |
- } |
- return false; |
-} |
- |
-// Create a collection of streams. |
-// CreateStreamCollection(1) creates a collection that |
-// correspond to kSdpStringWithStream1. |
-// CreateStreamCollection(2) correspond to kSdpStringWithStream1And2. |
-rtc::scoped_refptr<StreamCollection> CreateStreamCollection( |
- int number_of_streams, |
- int tracks_per_stream) { |
- rtc::scoped_refptr<StreamCollection> local_collection( |
- StreamCollection::Create()); |
- |
- for (int i = 0; i < number_of_streams; ++i) { |
- rtc::scoped_refptr<webrtc::MediaStreamInterface> stream( |
- webrtc::MediaStream::Create(kStreams[i])); |
- |
- for (int j = 0; j < tracks_per_stream; ++j) { |
- // Add a local audio track. |
- rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track( |
- webrtc::AudioTrack::Create(kAudioTracks[i * tracks_per_stream + j], |
- nullptr)); |
- stream->AddTrack(audio_track); |
- |
- // Add a local video track. |
- rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track( |
- webrtc::VideoTrack::Create(kVideoTracks[i * tracks_per_stream + j], |
- webrtc::FakeVideoTrackSource::Create())); |
- stream->AddTrack(video_track); |
- } |
- |
- local_collection->AddStream(stream); |
- } |
- return local_collection; |
-} |
- |
-// Check equality of StreamCollections. |
-bool CompareStreamCollections(StreamCollectionInterface* s1, |
- StreamCollectionInterface* s2) { |
- if (s1 == nullptr || s2 == nullptr || s1->count() != s2->count()) { |
- return false; |
- } |
- |
- for (size_t i = 0; i != s1->count(); ++i) { |
- if (s1->at(i)->label() != s2->at(i)->label()) { |
- return false; |
- } |
- webrtc::AudioTrackVector audio_tracks1 = s1->at(i)->GetAudioTracks(); |
- webrtc::AudioTrackVector audio_tracks2 = s2->at(i)->GetAudioTracks(); |
- webrtc::VideoTrackVector video_tracks1 = s1->at(i)->GetVideoTracks(); |
- webrtc::VideoTrackVector video_tracks2 = s2->at(i)->GetVideoTracks(); |
- |
- if (audio_tracks1.size() != audio_tracks2.size()) { |
- return false; |
- } |
- for (size_t j = 0; j != audio_tracks1.size(); ++j) { |
- if (audio_tracks1[j]->id() != audio_tracks2[j]->id()) { |
- return false; |
- } |
- } |
- if (video_tracks1.size() != video_tracks2.size()) { |
- return false; |
- } |
- for (size_t j = 0; j != video_tracks1.size(); ++j) { |
- if (video_tracks1[j]->id() != video_tracks2[j]->id()) { |
- return false; |
- } |
- } |
- } |
- return true; |
-} |
- |
-// Helper class to test Observer. |
-class MockTrackObserver : public ObserverInterface { |
- public: |
- explicit MockTrackObserver(NotifierInterface* notifier) |
- : notifier_(notifier) { |
- notifier_->RegisterObserver(this); |
- } |
- |
- ~MockTrackObserver() { Unregister(); } |
- |
- void Unregister() { |
- if (notifier_) { |
- notifier_->UnregisterObserver(this); |
- notifier_ = nullptr; |
- } |
- } |
- |
- MOCK_METHOD0(OnChanged, void()); |
- |
- private: |
- NotifierInterface* notifier_; |
-}; |
- |
-class MockPeerConnectionObserver : public PeerConnectionObserver { |
- public: |
- // We need these using declarations because there are two versions of each of |
- // the below methods and we only override one of them. |
- // TODO(deadbeef): Remove once there's only one version of the methods. |
- using PeerConnectionObserver::OnAddStream; |
- using PeerConnectionObserver::OnRemoveStream; |
- using PeerConnectionObserver::OnDataChannel; |
- |
- MockPeerConnectionObserver() : remote_streams_(StreamCollection::Create()) {} |
- virtual ~MockPeerConnectionObserver() { |
- } |
- void SetPeerConnectionInterface(PeerConnectionInterface* pc) { |
- pc_ = pc; |
- if (pc) { |
- state_ = pc_->signaling_state(); |
- } |
- } |
- void OnSignalingChange( |
- PeerConnectionInterface::SignalingState new_state) override { |
- EXPECT_EQ(pc_->signaling_state(), new_state); |
- state_ = new_state; |
- } |
- // TODO(bemasc): Remove this once callers transition to OnIceGatheringChange. |
- virtual void OnStateChange(StateType state_changed) { |
- if (pc_.get() == NULL) |
- return; |
- switch (state_changed) { |
- case kSignalingState: |
- // OnSignalingChange and OnStateChange(kSignalingState) should always |
- // be called approximately simultaneously. To ease testing, we require |
- // that they always be called in that order. This check verifies |
- // that OnSignalingChange has just been called. |
- EXPECT_EQ(pc_->signaling_state(), state_); |
- break; |
- case kIceState: |
- ADD_FAILURE(); |
- break; |
- default: |
- ADD_FAILURE(); |
- break; |
- } |
- } |
- |
- MediaStreamInterface* RemoteStream(const std::string& label) { |
- return remote_streams_->find(label); |
- } |
- StreamCollectionInterface* remote_streams() const { return remote_streams_; } |
- void OnAddStream(rtc::scoped_refptr<MediaStreamInterface> stream) override { |
- last_added_stream_ = stream; |
- remote_streams_->AddStream(stream); |
- } |
- void OnRemoveStream( |
- rtc::scoped_refptr<MediaStreamInterface> stream) override { |
- last_removed_stream_ = stream; |
- remote_streams_->RemoveStream(stream); |
- } |
- void OnRenegotiationNeeded() override { renegotiation_needed_ = true; } |
- void OnDataChannel( |
- rtc::scoped_refptr<DataChannelInterface> data_channel) override { |
- last_datachannel_ = data_channel; |
- } |
- |
- void OnIceConnectionChange( |
- PeerConnectionInterface::IceConnectionState new_state) override { |
- EXPECT_EQ(pc_->ice_connection_state(), new_state); |
- callback_triggered_ = true; |
- } |
- void OnIceGatheringChange( |
- PeerConnectionInterface::IceGatheringState new_state) override { |
- EXPECT_EQ(pc_->ice_gathering_state(), new_state); |
- ice_complete_ = new_state == PeerConnectionInterface::kIceGatheringComplete; |
- callback_triggered_ = true; |
- } |
- void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override { |
- EXPECT_NE(PeerConnectionInterface::kIceGatheringNew, |
- pc_->ice_gathering_state()); |
- |
- std::string sdp; |
- EXPECT_TRUE(candidate->ToString(&sdp)); |
- EXPECT_LT(0u, sdp.size()); |
- last_candidate_.reset(webrtc::CreateIceCandidate(candidate->sdp_mid(), |
- candidate->sdp_mline_index(), sdp, NULL)); |
- EXPECT_TRUE(last_candidate_.get() != NULL); |
- callback_triggered_ = true; |
- } |
- |
- void OnIceCandidatesRemoved( |
- const std::vector<cricket::Candidate>& candidates) override { |
- callback_triggered_ = true; |
- } |
- |
- void OnIceConnectionReceivingChange(bool receiving) override { |
- callback_triggered_ = true; |
- } |
- |
- void OnAddTrack( |
- rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver, |
- const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>& |
- streams) override { |
- EXPECT_TRUE(receiver != nullptr); |
- num_added_tracks_++; |
- last_added_track_label_ = receiver->id(); |
- } |
- |
- // Returns the label of the last added stream. |
- // Empty string if no stream have been added. |
- std::string GetLastAddedStreamLabel() { |
- if (last_added_stream_.get()) |
- return last_added_stream_->label(); |
- return ""; |
- } |
- std::string GetLastRemovedStreamLabel() { |
- if (last_removed_stream_.get()) |
- return last_removed_stream_->label(); |
- return ""; |
- } |
- |
- rtc::scoped_refptr<PeerConnectionInterface> pc_; |
- PeerConnectionInterface::SignalingState state_; |
- std::unique_ptr<IceCandidateInterface> last_candidate_; |
- rtc::scoped_refptr<DataChannelInterface> last_datachannel_; |
- rtc::scoped_refptr<StreamCollection> remote_streams_; |
- bool renegotiation_needed_ = false; |
- bool ice_complete_ = false; |
- bool callback_triggered_ = false; |
- int num_added_tracks_ = 0; |
- std::string last_added_track_label_; |
- |
- private: |
- rtc::scoped_refptr<MediaStreamInterface> last_added_stream_; |
- rtc::scoped_refptr<MediaStreamInterface> last_removed_stream_; |
-}; |
- |
-} // namespace |
- |
-// The PeerConnectionMediaConfig tests below verify that configuration |
-// and constraints are propagated into the MediaConfig passed to |
-// CreateMediaController. These settings are intended for MediaChannel |
-// constructors, but that is not exercised by these unittest. |
-class PeerConnectionFactoryForTest : public webrtc::PeerConnectionFactory { |
- public: |
- webrtc::MediaControllerInterface* CreateMediaController( |
- const cricket::MediaConfig& config, |
- webrtc::RtcEventLog* event_log) const override { |
- create_media_controller_called_ = true; |
- create_media_controller_config_ = config; |
- |
- webrtc::MediaControllerInterface* mc = |
- PeerConnectionFactory::CreateMediaController(config, event_log); |
- EXPECT_TRUE(mc != nullptr); |
- return mc; |
- } |
- |
- cricket::TransportController* CreateTransportController( |
- cricket::PortAllocator* port_allocator, |
- bool redetermine_role_on_ice_restart) override { |
- transport_controller = new cricket::TransportController( |
- rtc::Thread::Current(), rtc::Thread::Current(), port_allocator, |
- redetermine_role_on_ice_restart); |
- return transport_controller; |
- } |
- |
- cricket::TransportController* transport_controller; |
- // Mutable, so they can be modified in the above const-declared method. |
- mutable bool create_media_controller_called_ = false; |
- mutable cricket::MediaConfig create_media_controller_config_; |
-}; |
- |
-class PeerConnectionInterfaceTest : public testing::Test { |
- protected: |
- PeerConnectionInterfaceTest() { |
-#ifdef WEBRTC_ANDROID |
- webrtc::InitializeAndroidObjects(); |
-#endif |
- } |
- |
- virtual void SetUp() { |
- pc_factory_ = webrtc::CreatePeerConnectionFactory( |
- rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(), |
- nullptr, nullptr, nullptr); |
- ASSERT_TRUE(pc_factory_); |
- pc_factory_for_test_ = |
- new rtc::RefCountedObject<PeerConnectionFactoryForTest>(); |
- pc_factory_for_test_->Initialize(); |
- } |
- |
- void CreatePeerConnection() { |
- CreatePeerConnection(PeerConnectionInterface::RTCConfiguration(), nullptr); |
- } |
- |
- // DTLS does not work in a loopback call, so is disabled for most of the |
- // tests in this file. |
- void CreatePeerConnectionWithoutDtls() { |
- FakeConstraints no_dtls_constraints; |
- no_dtls_constraints.AddMandatory( |
- webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, false); |
- |
- CreatePeerConnection(PeerConnectionInterface::RTCConfiguration(), |
- &no_dtls_constraints); |
- } |
- |
- void CreatePeerConnection(webrtc::MediaConstraintsInterface* constraints) { |
- CreatePeerConnection(PeerConnectionInterface::RTCConfiguration(), |
- constraints); |
- } |
- |
- void CreatePeerConnectionWithIceTransportsType( |
- PeerConnectionInterface::IceTransportsType type) { |
- PeerConnectionInterface::RTCConfiguration config; |
- config.type = type; |
- return CreatePeerConnection(config, nullptr); |
- } |
- |
- void CreatePeerConnectionWithIceServer(const std::string& uri, |
- const std::string& password) { |
- PeerConnectionInterface::RTCConfiguration config; |
- PeerConnectionInterface::IceServer server; |
- server.uri = uri; |
- server.password = password; |
- config.servers.push_back(server); |
- CreatePeerConnection(config, nullptr); |
- } |
- |
- void CreatePeerConnection(PeerConnectionInterface::RTCConfiguration config, |
- webrtc::MediaConstraintsInterface* constraints) { |
- std::unique_ptr<cricket::FakePortAllocator> port_allocator( |
- new cricket::FakePortAllocator(rtc::Thread::Current(), nullptr)); |
- port_allocator_ = port_allocator.get(); |
- |
- std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator; |
- bool dtls; |
- if (FindConstraint(constraints, |
- webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- &dtls, |
- nullptr) && dtls) { |
- fake_certificate_generator_ = new FakeRTCCertificateGenerator(); |
- cert_generator.reset(fake_certificate_generator_); |
- } |
- pc_ = pc_factory_->CreatePeerConnection( |
- config, constraints, std::move(port_allocator), |
- std::move(cert_generator), &observer_); |
- ASSERT_TRUE(pc_.get() != NULL); |
- observer_.SetPeerConnectionInterface(pc_.get()); |
- EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_); |
- } |
- |
- void CreatePeerConnectionExpectFail(const std::string& uri) { |
- PeerConnectionInterface::RTCConfiguration config; |
- PeerConnectionInterface::IceServer server; |
- server.uri = uri; |
- config.servers.push_back(server); |
- |
- rtc::scoped_refptr<PeerConnectionInterface> pc; |
- pc = pc_factory_->CreatePeerConnection(config, nullptr, nullptr, nullptr, |
- &observer_); |
- EXPECT_EQ(nullptr, pc); |
- } |
- |
- void CreatePeerConnectionWithDifferentConfigurations() { |
- CreatePeerConnectionWithIceServer(kStunAddressOnly, ""); |
- EXPECT_EQ(1u, port_allocator_->stun_servers().size()); |
- EXPECT_EQ(0u, port_allocator_->turn_servers().size()); |
- EXPECT_EQ("address", port_allocator_->stun_servers().begin()->hostname()); |
- EXPECT_EQ(kDefaultStunPort, |
- port_allocator_->stun_servers().begin()->port()); |
- |
- CreatePeerConnectionExpectFail(kStunInvalidPort); |
- CreatePeerConnectionExpectFail(kStunAddressPortAndMore1); |
- CreatePeerConnectionExpectFail(kStunAddressPortAndMore2); |
- |
- CreatePeerConnectionWithIceServer(kTurnIceServerUri, kTurnPassword); |
- EXPECT_EQ(0u, port_allocator_->stun_servers().size()); |
- EXPECT_EQ(1u, port_allocator_->turn_servers().size()); |
- EXPECT_EQ(kTurnUsername, |
- port_allocator_->turn_servers()[0].credentials.username); |
- EXPECT_EQ(kTurnPassword, |
- port_allocator_->turn_servers()[0].credentials.password); |
- EXPECT_EQ(kTurnHostname, |
- port_allocator_->turn_servers()[0].ports[0].address.hostname()); |
- } |
- |
- void ReleasePeerConnection() { |
- pc_ = NULL; |
- observer_.SetPeerConnectionInterface(NULL); |
- } |
- |
- void AddVideoStream(const std::string& label) { |
- // Create a local stream. |
- rtc::scoped_refptr<MediaStreamInterface> stream( |
- pc_factory_->CreateLocalMediaStream(label)); |
- rtc::scoped_refptr<VideoTrackSourceInterface> video_source( |
- pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer(), NULL)); |
- rtc::scoped_refptr<VideoTrackInterface> video_track( |
- pc_factory_->CreateVideoTrack(label + "v0", video_source)); |
- stream->AddTrack(video_track.get()); |
- EXPECT_TRUE(pc_->AddStream(stream)); |
- EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout); |
- observer_.renegotiation_needed_ = false; |
- } |
- |
- void AddVoiceStream(const std::string& label) { |
- // Create a local stream. |
- rtc::scoped_refptr<MediaStreamInterface> stream( |
- pc_factory_->CreateLocalMediaStream(label)); |
- rtc::scoped_refptr<AudioTrackInterface> audio_track( |
- pc_factory_->CreateAudioTrack(label + "a0", NULL)); |
- stream->AddTrack(audio_track.get()); |
- EXPECT_TRUE(pc_->AddStream(stream)); |
- EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout); |
- observer_.renegotiation_needed_ = false; |
- } |
- |
- void AddAudioVideoStream(const std::string& stream_label, |
- const std::string& audio_track_label, |
- const std::string& video_track_label) { |
- // Create a local stream. |
- rtc::scoped_refptr<MediaStreamInterface> stream( |
- pc_factory_->CreateLocalMediaStream(stream_label)); |
- rtc::scoped_refptr<AudioTrackInterface> audio_track( |
- pc_factory_->CreateAudioTrack( |
- audio_track_label, static_cast<AudioSourceInterface*>(NULL))); |
- stream->AddTrack(audio_track.get()); |
- rtc::scoped_refptr<VideoTrackInterface> video_track( |
- pc_factory_->CreateVideoTrack( |
- video_track_label, |
- pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer()))); |
- stream->AddTrack(video_track.get()); |
- EXPECT_TRUE(pc_->AddStream(stream)); |
- EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout); |
- observer_.renegotiation_needed_ = false; |
- } |
- |
- bool DoCreateOfferAnswer(std::unique_ptr<SessionDescriptionInterface>* desc, |
- bool offer, |
- MediaConstraintsInterface* constraints) { |
- rtc::scoped_refptr<MockCreateSessionDescriptionObserver> |
- observer(new rtc::RefCountedObject< |
- MockCreateSessionDescriptionObserver>()); |
- if (offer) { |
- pc_->CreateOffer(observer, constraints); |
- } else { |
- pc_->CreateAnswer(observer, constraints); |
- } |
- EXPECT_EQ_WAIT(true, observer->called(), kTimeout); |
- desc->reset(observer->release_desc()); |
- return observer->result(); |
- } |
- |
- bool DoCreateOffer(std::unique_ptr<SessionDescriptionInterface>* desc, |
- MediaConstraintsInterface* constraints) { |
- return DoCreateOfferAnswer(desc, true, constraints); |
- } |
- |
- bool DoCreateAnswer(std::unique_ptr<SessionDescriptionInterface>* desc, |
- MediaConstraintsInterface* constraints) { |
- return DoCreateOfferAnswer(desc, false, constraints); |
- } |
- |
- bool DoSetSessionDescription(SessionDescriptionInterface* desc, bool local) { |
- rtc::scoped_refptr<MockSetSessionDescriptionObserver> |
- observer(new rtc::RefCountedObject< |
- MockSetSessionDescriptionObserver>()); |
- if (local) { |
- pc_->SetLocalDescription(observer, desc); |
- } else { |
- pc_->SetRemoteDescription(observer, desc); |
- } |
- if (pc_->signaling_state() != PeerConnectionInterface::kClosed) { |
- EXPECT_EQ_WAIT(true, observer->called(), kTimeout); |
- } |
- return observer->result(); |
- } |
- |
- bool DoSetLocalDescription(SessionDescriptionInterface* desc) { |
- return DoSetSessionDescription(desc, true); |
- } |
- |
- bool DoSetRemoteDescription(SessionDescriptionInterface* desc) { |
- return DoSetSessionDescription(desc, false); |
- } |
- |
- // Calls PeerConnection::GetStats and check the return value. |
- // It does not verify the values in the StatReports since a RTCP packet might |
- // be required. |
- bool DoGetStats(MediaStreamTrackInterface* track) { |
- rtc::scoped_refptr<MockStatsObserver> observer( |
- new rtc::RefCountedObject<MockStatsObserver>()); |
- if (!pc_->GetStats( |
- observer, track, PeerConnectionInterface::kStatsOutputLevelStandard)) |
- return false; |
- EXPECT_TRUE_WAIT(observer->called(), kTimeout); |
- return observer->called(); |
- } |
- |
- void InitiateCall() { |
- CreatePeerConnectionWithoutDtls(); |
- // Create a local stream with audio&video tracks. |
- AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label"); |
- CreateOfferReceiveAnswer(); |
- } |
- |
- // Verify that RTP Header extensions has been negotiated for audio and video. |
- void VerifyRemoteRtpHeaderExtensions() { |
- const cricket::MediaContentDescription* desc = |
- cricket::GetFirstAudioContentDescription( |
- pc_->remote_description()->description()); |
- ASSERT_TRUE(desc != NULL); |
- EXPECT_GT(desc->rtp_header_extensions().size(), 0u); |
- |
- desc = cricket::GetFirstVideoContentDescription( |
- pc_->remote_description()->description()); |
- ASSERT_TRUE(desc != NULL); |
- EXPECT_GT(desc->rtp_header_extensions().size(), 0u); |
- } |
- |
- void CreateOfferAsRemoteDescription() { |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- std::string sdp; |
- EXPECT_TRUE(offer->ToString(&sdp)); |
- SessionDescriptionInterface* remote_offer = |
- webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer, |
- sdp, NULL); |
- EXPECT_TRUE(DoSetRemoteDescription(remote_offer)); |
- EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_); |
- } |
- |
- void CreateAndSetRemoteOffer(const std::string& sdp) { |
- SessionDescriptionInterface* remote_offer = |
- webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer, |
- sdp, nullptr); |
- EXPECT_TRUE(DoSetRemoteDescription(remote_offer)); |
- EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_); |
- } |
- |
- void CreateAnswerAsLocalDescription() { |
- std::unique_ptr<SessionDescriptionInterface> answer; |
- ASSERT_TRUE(DoCreateAnswer(&answer, nullptr)); |
- |
- // TODO(perkj): Currently SetLocalDescription fails if any parameters in an |
- // audio codec change, even if the parameter has nothing to do with |
- // receiving. Not all parameters are serialized to SDP. |
- // Since CreatePrAnswerAsLocalDescription serialize/deserialize |
- // the SessionDescription, it is necessary to do that here to in order to |
- // get ReceiveOfferCreatePrAnswerAndAnswer and RenegotiateAudioOnly to pass. |
- // https://code.google.com/p/webrtc/issues/detail?id=1356 |
- std::string sdp; |
- EXPECT_TRUE(answer->ToString(&sdp)); |
- SessionDescriptionInterface* new_answer = |
- webrtc::CreateSessionDescription(SessionDescriptionInterface::kAnswer, |
- sdp, NULL); |
- EXPECT_TRUE(DoSetLocalDescription(new_answer)); |
- EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_); |
- } |
- |
- void CreatePrAnswerAsLocalDescription() { |
- std::unique_ptr<SessionDescriptionInterface> answer; |
- ASSERT_TRUE(DoCreateAnswer(&answer, nullptr)); |
- |
- std::string sdp; |
- EXPECT_TRUE(answer->ToString(&sdp)); |
- SessionDescriptionInterface* pr_answer = |
- webrtc::CreateSessionDescription(SessionDescriptionInterface::kPrAnswer, |
- sdp, NULL); |
- EXPECT_TRUE(DoSetLocalDescription(pr_answer)); |
- EXPECT_EQ(PeerConnectionInterface::kHaveLocalPrAnswer, observer_.state_); |
- } |
- |
- void CreateOfferReceiveAnswer() { |
- CreateOfferAsLocalDescription(); |
- std::string sdp; |
- EXPECT_TRUE(pc_->local_description()->ToString(&sdp)); |
- CreateAnswerAsRemoteDescription(sdp); |
- } |
- |
- void CreateOfferAsLocalDescription() { |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- // TODO(perkj): Currently SetLocalDescription fails if any parameters in an |
- // audio codec change, even if the parameter has nothing to do with |
- // receiving. Not all parameters are serialized to SDP. |
- // Since CreatePrAnswerAsLocalDescription serialize/deserialize |
- // the SessionDescription, it is necessary to do that here to in order to |
- // get ReceiveOfferCreatePrAnswerAndAnswer and RenegotiateAudioOnly to pass. |
- // https://code.google.com/p/webrtc/issues/detail?id=1356 |
- std::string sdp; |
- EXPECT_TRUE(offer->ToString(&sdp)); |
- SessionDescriptionInterface* new_offer = |
- webrtc::CreateSessionDescription( |
- SessionDescriptionInterface::kOffer, |
- sdp, NULL); |
- |
- EXPECT_TRUE(DoSetLocalDescription(new_offer)); |
- EXPECT_EQ(PeerConnectionInterface::kHaveLocalOffer, observer_.state_); |
- // Wait for the ice_complete message, so that SDP will have candidates. |
- EXPECT_TRUE_WAIT(observer_.ice_complete_, kTimeout); |
- } |
- |
- void CreateAnswerAsRemoteDescription(const std::string& sdp) { |
- webrtc::JsepSessionDescription* answer = new webrtc::JsepSessionDescription( |
- SessionDescriptionInterface::kAnswer); |
- EXPECT_TRUE(answer->Initialize(sdp, NULL)); |
- EXPECT_TRUE(DoSetRemoteDescription(answer)); |
- EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_); |
- } |
- |
- void CreatePrAnswerAndAnswerAsRemoteDescription(const std::string& sdp) { |
- webrtc::JsepSessionDescription* pr_answer = |
- new webrtc::JsepSessionDescription( |
- SessionDescriptionInterface::kPrAnswer); |
- EXPECT_TRUE(pr_answer->Initialize(sdp, NULL)); |
- EXPECT_TRUE(DoSetRemoteDescription(pr_answer)); |
- EXPECT_EQ(PeerConnectionInterface::kHaveRemotePrAnswer, observer_.state_); |
- webrtc::JsepSessionDescription* answer = |
- new webrtc::JsepSessionDescription( |
- SessionDescriptionInterface::kAnswer); |
- EXPECT_TRUE(answer->Initialize(sdp, NULL)); |
- EXPECT_TRUE(DoSetRemoteDescription(answer)); |
- EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_); |
- } |
- |
- // Help function used for waiting until a the last signaled remote stream has |
- // the same label as |stream_label|. In a few of the tests in this file we |
- // answer with the same session description as we offer and thus we can |
- // check if OnAddStream have been called with the same stream as we offer to |
- // send. |
- void WaitAndVerifyOnAddStream(const std::string& stream_label) { |
- EXPECT_EQ_WAIT(stream_label, observer_.GetLastAddedStreamLabel(), kTimeout); |
- } |
- |
- // Creates an offer and applies it as a local session description. |
- // Creates an answer with the same SDP an the offer but removes all lines |
- // that start with a:ssrc" |
- void CreateOfferReceiveAnswerWithoutSsrc() { |
- CreateOfferAsLocalDescription(); |
- std::string sdp; |
- EXPECT_TRUE(pc_->local_description()->ToString(&sdp)); |
- SetSsrcToZero(&sdp); |
- CreateAnswerAsRemoteDescription(sdp); |
- } |
- |
- // This function creates a MediaStream with label kStreams[0] and |
- // |number_of_audio_tracks| and |number_of_video_tracks| tracks and the |
- // corresponding SessionDescriptionInterface. The SessionDescriptionInterface |
- // is returned and the MediaStream is stored in |
- // |reference_collection_| |
- std::unique_ptr<SessionDescriptionInterface> |
- CreateSessionDescriptionAndReference(size_t number_of_audio_tracks, |
- size_t number_of_video_tracks) { |
- EXPECT_LE(number_of_audio_tracks, 2u); |
- EXPECT_LE(number_of_video_tracks, 2u); |
- |
- reference_collection_ = StreamCollection::Create(); |
- std::string sdp_ms1 = std::string(kSdpStringInit); |
- |
- std::string mediastream_label = kStreams[0]; |
- |
- rtc::scoped_refptr<webrtc::MediaStreamInterface> stream( |
- webrtc::MediaStream::Create(mediastream_label)); |
- reference_collection_->AddStream(stream); |
- |
- if (number_of_audio_tracks > 0) { |
- sdp_ms1 += std::string(kSdpStringAudio); |
- sdp_ms1 += std::string(kSdpStringMs1Audio0); |
- AddAudioTrack(kAudioTracks[0], stream); |
- } |
- if (number_of_audio_tracks > 1) { |
- sdp_ms1 += kSdpStringMs1Audio1; |
- AddAudioTrack(kAudioTracks[1], stream); |
- } |
- |
- if (number_of_video_tracks > 0) { |
- sdp_ms1 += std::string(kSdpStringVideo); |
- sdp_ms1 += std::string(kSdpStringMs1Video0); |
- AddVideoTrack(kVideoTracks[0], stream); |
- } |
- if (number_of_video_tracks > 1) { |
- sdp_ms1 += kSdpStringMs1Video1; |
- AddVideoTrack(kVideoTracks[1], stream); |
- } |
- |
- return std::unique_ptr<SessionDescriptionInterface>( |
- webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer, |
- sdp_ms1, nullptr)); |
- } |
- |
- void AddAudioTrack(const std::string& track_id, |
- MediaStreamInterface* stream) { |
- rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track( |
- webrtc::AudioTrack::Create(track_id, nullptr)); |
- ASSERT_TRUE(stream->AddTrack(audio_track)); |
- } |
- |
- void AddVideoTrack(const std::string& track_id, |
- MediaStreamInterface* stream) { |
- rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track( |
- webrtc::VideoTrack::Create(track_id, |
- webrtc::FakeVideoTrackSource::Create())); |
- ASSERT_TRUE(stream->AddTrack(video_track)); |
- } |
- |
- std::unique_ptr<SessionDescriptionInterface> CreateOfferWithOneAudioStream() { |
- CreatePeerConnectionWithoutDtls(); |
- AddVoiceStream(kStreamLabel1); |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- EXPECT_TRUE(DoCreateOffer(&offer, nullptr)); |
- return offer; |
- } |
- |
- std::unique_ptr<SessionDescriptionInterface> |
- CreateAnswerWithOneAudioStream() { |
- std::unique_ptr<SessionDescriptionInterface> offer = |
- CreateOfferWithOneAudioStream(); |
- EXPECT_TRUE(DoSetRemoteDescription(offer.release())); |
- std::unique_ptr<SessionDescriptionInterface> answer; |
- EXPECT_TRUE(DoCreateAnswer(&answer, nullptr)); |
- return answer; |
- } |
- |
- const std::string& GetFirstAudioStreamCname( |
- const SessionDescriptionInterface* desc) { |
- const cricket::ContentInfo* audio_content = |
- cricket::GetFirstAudioContent(desc->description()); |
- const cricket::AudioContentDescription* audio_desc = |
- static_cast<const cricket::AudioContentDescription*>( |
- audio_content->description); |
- return audio_desc->streams()[0].cname; |
- } |
- |
- cricket::FakePortAllocator* port_allocator_ = nullptr; |
- FakeRTCCertificateGenerator* fake_certificate_generator_ = nullptr; |
- rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory_; |
- rtc::scoped_refptr<PeerConnectionFactoryForTest> pc_factory_for_test_; |
- rtc::scoped_refptr<PeerConnectionInterface> pc_; |
- MockPeerConnectionObserver observer_; |
- rtc::scoped_refptr<StreamCollection> reference_collection_; |
-}; |
- |
-// Test that no callbacks on the PeerConnectionObserver are called after the |
-// PeerConnection is closed. |
-TEST_F(PeerConnectionInterfaceTest, CloseAndTestCallbackFunctions) { |
- rtc::scoped_refptr<PeerConnectionInterface> pc( |
- pc_factory_for_test_->CreatePeerConnection( |
- PeerConnectionInterface::RTCConfiguration(), nullptr, nullptr, |
- nullptr, &observer_)); |
- observer_.SetPeerConnectionInterface(pc.get()); |
- pc->Close(); |
- |
- // No callbacks is expected to be called. |
- observer_.callback_triggered_ = false; |
- std::vector<cricket::Candidate> candidates; |
- pc_factory_for_test_->transport_controller->SignalGatheringState( |
- cricket::IceGatheringState{}); |
- pc_factory_for_test_->transport_controller->SignalCandidatesGathered( |
- "", candidates); |
- pc_factory_for_test_->transport_controller->SignalConnectionState( |
- cricket::IceConnectionState{}); |
- pc_factory_for_test_->transport_controller->SignalCandidatesRemoved( |
- candidates); |
- pc_factory_for_test_->transport_controller->SignalReceiving(false); |
- EXPECT_FALSE(observer_.callback_triggered_); |
-} |
- |
-// Generate different CNAMEs when PeerConnections are created. |
-// The CNAMEs are expected to be generated randomly. It is possible |
-// that the test fails, though the possibility is very low. |
-TEST_F(PeerConnectionInterfaceTest, CnameGenerationInOffer) { |
- std::unique_ptr<SessionDescriptionInterface> offer1 = |
- CreateOfferWithOneAudioStream(); |
- std::unique_ptr<SessionDescriptionInterface> offer2 = |
- CreateOfferWithOneAudioStream(); |
- EXPECT_NE(GetFirstAudioStreamCname(offer1.get()), |
- GetFirstAudioStreamCname(offer2.get())); |
-} |
- |
-TEST_F(PeerConnectionInterfaceTest, CnameGenerationInAnswer) { |
- std::unique_ptr<SessionDescriptionInterface> answer1 = |
- CreateAnswerWithOneAudioStream(); |
- std::unique_ptr<SessionDescriptionInterface> answer2 = |
- CreateAnswerWithOneAudioStream(); |
- EXPECT_NE(GetFirstAudioStreamCname(answer1.get()), |
- GetFirstAudioStreamCname(answer2.get())); |
-} |
- |
-TEST_F(PeerConnectionInterfaceTest, |
- CreatePeerConnectionWithDifferentConfigurations) { |
- CreatePeerConnectionWithDifferentConfigurations(); |
-} |
- |
-TEST_F(PeerConnectionInterfaceTest, |
- CreatePeerConnectionWithDifferentIceTransportsTypes) { |
- CreatePeerConnectionWithIceTransportsType(PeerConnectionInterface::kNone); |
- EXPECT_EQ(cricket::CF_NONE, port_allocator_->candidate_filter()); |
- CreatePeerConnectionWithIceTransportsType(PeerConnectionInterface::kRelay); |
- EXPECT_EQ(cricket::CF_RELAY, port_allocator_->candidate_filter()); |
- CreatePeerConnectionWithIceTransportsType(PeerConnectionInterface::kNoHost); |
- EXPECT_EQ(cricket::CF_ALL & ~cricket::CF_HOST, |
- port_allocator_->candidate_filter()); |
- CreatePeerConnectionWithIceTransportsType(PeerConnectionInterface::kAll); |
- EXPECT_EQ(cricket::CF_ALL, port_allocator_->candidate_filter()); |
-} |
- |
-// Test that when a PeerConnection is created with a nonzero candidate pool |
-// size, the pooled PortAllocatorSession is created with all the attributes |
-// in the RTCConfiguration. |
-TEST_F(PeerConnectionInterfaceTest, CreatePeerConnectionWithPooledCandidates) { |
- PeerConnectionInterface::RTCConfiguration config; |
- PeerConnectionInterface::IceServer server; |
- server.uri = kStunAddressOnly; |
- config.servers.push_back(server); |
- config.type = PeerConnectionInterface::kRelay; |
- config.disable_ipv6 = true; |
- config.tcp_candidate_policy = |
- PeerConnectionInterface::kTcpCandidatePolicyDisabled; |
- config.candidate_network_policy = |
- PeerConnectionInterface::kCandidateNetworkPolicyLowCost; |
- config.ice_candidate_pool_size = 1; |
- CreatePeerConnection(config, nullptr); |
- |
- const cricket::FakePortAllocatorSession* session = |
- static_cast<const cricket::FakePortAllocatorSession*>( |
- port_allocator_->GetPooledSession()); |
- ASSERT_NE(nullptr, session); |
- EXPECT_EQ(1UL, session->stun_servers().size()); |
- EXPECT_EQ(0U, session->flags() & cricket::PORTALLOCATOR_ENABLE_IPV6); |
- EXPECT_LT(0U, session->flags() & cricket::PORTALLOCATOR_DISABLE_TCP); |
- EXPECT_LT(0U, |
- session->flags() & cricket::PORTALLOCATOR_DISABLE_COSTLY_NETWORKS); |
-} |
- |
-// Test that the PeerConnection initializes the port allocator passed into it, |
-// and on the correct thread. |
-TEST_F(PeerConnectionInterfaceTest, |
- CreatePeerConnectionInitializesPortAllocator) { |
- rtc::Thread network_thread; |
- network_thread.Start(); |
- rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory( |
- webrtc::CreatePeerConnectionFactory( |
- &network_thread, rtc::Thread::Current(), rtc::Thread::Current(), |
- nullptr, nullptr, nullptr)); |
- std::unique_ptr<cricket::FakePortAllocator> port_allocator( |
- new cricket::FakePortAllocator(&network_thread, nullptr)); |
- cricket::FakePortAllocator* raw_port_allocator = port_allocator.get(); |
- PeerConnectionInterface::RTCConfiguration config; |
- rtc::scoped_refptr<PeerConnectionInterface> pc( |
- pc_factory->CreatePeerConnection( |
- config, nullptr, std::move(port_allocator), nullptr, &observer_)); |
- // FakePortAllocator RTC_CHECKs that it's initialized on the right thread, |
- // so all we have to do here is check that it's initialized. |
- EXPECT_TRUE(raw_port_allocator->initialized()); |
-} |
- |
-// Check that GetConfiguration returns the configuration the PeerConnection was |
-// constructed with, before SetConfiguration is called. |
-TEST_F(PeerConnectionInterfaceTest, GetConfigurationAfterCreatePeerConnection) { |
- PeerConnectionInterface::RTCConfiguration config; |
- config.type = PeerConnectionInterface::kRelay; |
- CreatePeerConnection(config, nullptr); |
- |
- PeerConnectionInterface::RTCConfiguration returned_config = |
- pc_->GetConfiguration(); |
- EXPECT_EQ(PeerConnectionInterface::kRelay, returned_config.type); |
-} |
- |
-// Check that GetConfiguration returns the last configuration passed into |
-// SetConfiguration. |
-TEST_F(PeerConnectionInterfaceTest, GetConfigurationAfterSetConfiguration) { |
- CreatePeerConnection(); |
- |
- PeerConnectionInterface::RTCConfiguration config; |
- config.type = PeerConnectionInterface::kRelay; |
- EXPECT_TRUE(pc_->SetConfiguration(config)); |
- |
- PeerConnectionInterface::RTCConfiguration returned_config = |
- pc_->GetConfiguration(); |
- EXPECT_EQ(PeerConnectionInterface::kRelay, returned_config.type); |
-} |
- |
-TEST_F(PeerConnectionInterfaceTest, AddStreams) { |
- CreatePeerConnectionWithoutDtls(); |
- AddVideoStream(kStreamLabel1); |
- AddVoiceStream(kStreamLabel2); |
- ASSERT_EQ(2u, pc_->local_streams()->count()); |
- |
- // Test we can add multiple local streams to one peerconnection. |
- rtc::scoped_refptr<MediaStreamInterface> stream( |
- pc_factory_->CreateLocalMediaStream(kStreamLabel3)); |
- rtc::scoped_refptr<AudioTrackInterface> audio_track( |
- pc_factory_->CreateAudioTrack(kStreamLabel3, |
- static_cast<AudioSourceInterface*>(NULL))); |
- stream->AddTrack(audio_track.get()); |
- EXPECT_TRUE(pc_->AddStream(stream)); |
- EXPECT_EQ(3u, pc_->local_streams()->count()); |
- |
- // Remove the third stream. |
- pc_->RemoveStream(pc_->local_streams()->at(2)); |
- EXPECT_EQ(2u, pc_->local_streams()->count()); |
- |
- // Remove the second stream. |
- pc_->RemoveStream(pc_->local_streams()->at(1)); |
- EXPECT_EQ(1u, pc_->local_streams()->count()); |
- |
- // Remove the first stream. |
- pc_->RemoveStream(pc_->local_streams()->at(0)); |
- EXPECT_EQ(0u, pc_->local_streams()->count()); |
-} |
- |
-// Test that the created offer includes streams we added. |
-TEST_F(PeerConnectionInterfaceTest, AddedStreamsPresentInOffer) { |
- CreatePeerConnectionWithoutDtls(); |
- AddAudioVideoStream(kStreamLabel1, "audio_track", "video_track"); |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- |
- const cricket::ContentInfo* audio_content = |
- cricket::GetFirstAudioContent(offer->description()); |
- const cricket::AudioContentDescription* audio_desc = |
- static_cast<const cricket::AudioContentDescription*>( |
- audio_content->description); |
- EXPECT_TRUE( |
- ContainsTrack(audio_desc->streams(), kStreamLabel1, "audio_track")); |
- |
- const cricket::ContentInfo* video_content = |
- cricket::GetFirstVideoContent(offer->description()); |
- const cricket::VideoContentDescription* video_desc = |
- static_cast<const cricket::VideoContentDescription*>( |
- video_content->description); |
- EXPECT_TRUE( |
- ContainsTrack(video_desc->streams(), kStreamLabel1, "video_track")); |
- |
- // Add another stream and ensure the offer includes both the old and new |
- // streams. |
- AddAudioVideoStream(kStreamLabel2, "audio_track2", "video_track2"); |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- |
- audio_content = cricket::GetFirstAudioContent(offer->description()); |
- audio_desc = static_cast<const cricket::AudioContentDescription*>( |
- audio_content->description); |
- EXPECT_TRUE( |
- ContainsTrack(audio_desc->streams(), kStreamLabel1, "audio_track")); |
- EXPECT_TRUE( |
- ContainsTrack(audio_desc->streams(), kStreamLabel2, "audio_track2")); |
- |
- video_content = cricket::GetFirstVideoContent(offer->description()); |
- video_desc = static_cast<const cricket::VideoContentDescription*>( |
- video_content->description); |
- EXPECT_TRUE( |
- ContainsTrack(video_desc->streams(), kStreamLabel1, "video_track")); |
- EXPECT_TRUE( |
- ContainsTrack(video_desc->streams(), kStreamLabel2, "video_track2")); |
-} |
- |
-TEST_F(PeerConnectionInterfaceTest, RemoveStream) { |
- CreatePeerConnectionWithoutDtls(); |
- AddVideoStream(kStreamLabel1); |
- ASSERT_EQ(1u, pc_->local_streams()->count()); |
- pc_->RemoveStream(pc_->local_streams()->at(0)); |
- EXPECT_EQ(0u, pc_->local_streams()->count()); |
-} |
- |
-// Test for AddTrack and RemoveTrack methods. |
-// Tests that the created offer includes tracks we added, |
-// and that the RtpSenders are created correctly. |
-// Also tests that RemoveTrack removes the tracks from subsequent offers. |
-TEST_F(PeerConnectionInterfaceTest, AddTrackRemoveTrack) { |
- CreatePeerConnectionWithoutDtls(); |
- // Create a dummy stream, so tracks share a stream label. |
- rtc::scoped_refptr<MediaStreamInterface> stream( |
- pc_factory_->CreateLocalMediaStream(kStreamLabel1)); |
- std::vector<MediaStreamInterface*> stream_list; |
- stream_list.push_back(stream.get()); |
- rtc::scoped_refptr<AudioTrackInterface> audio_track( |
- pc_factory_->CreateAudioTrack("audio_track", nullptr)); |
- rtc::scoped_refptr<VideoTrackInterface> video_track( |
- pc_factory_->CreateVideoTrack( |
- "video_track", |
- pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer()))); |
- auto audio_sender = pc_->AddTrack(audio_track, stream_list); |
- auto video_sender = pc_->AddTrack(video_track, stream_list); |
- EXPECT_EQ(1UL, audio_sender->stream_ids().size()); |
- EXPECT_EQ(kStreamLabel1, audio_sender->stream_ids()[0]); |
- EXPECT_EQ("audio_track", audio_sender->id()); |
- EXPECT_EQ(audio_track, audio_sender->track()); |
- EXPECT_EQ(1UL, video_sender->stream_ids().size()); |
- EXPECT_EQ(kStreamLabel1, video_sender->stream_ids()[0]); |
- EXPECT_EQ("video_track", video_sender->id()); |
- EXPECT_EQ(video_track, video_sender->track()); |
- |
- // Now create an offer and check for the senders. |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- |
- const cricket::ContentInfo* audio_content = |
- cricket::GetFirstAudioContent(offer->description()); |
- const cricket::AudioContentDescription* audio_desc = |
- static_cast<const cricket::AudioContentDescription*>( |
- audio_content->description); |
- EXPECT_TRUE( |
- ContainsTrack(audio_desc->streams(), kStreamLabel1, "audio_track")); |
- |
- const cricket::ContentInfo* video_content = |
- cricket::GetFirstVideoContent(offer->description()); |
- const cricket::VideoContentDescription* video_desc = |
- static_cast<const cricket::VideoContentDescription*>( |
- video_content->description); |
- EXPECT_TRUE( |
- ContainsTrack(video_desc->streams(), kStreamLabel1, "video_track")); |
- |
- EXPECT_TRUE(DoSetLocalDescription(offer.release())); |
- |
- // Now try removing the tracks. |
- EXPECT_TRUE(pc_->RemoveTrack(audio_sender)); |
- EXPECT_TRUE(pc_->RemoveTrack(video_sender)); |
- |
- // Create a new offer and ensure it doesn't contain the removed senders. |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- |
- audio_content = cricket::GetFirstAudioContent(offer->description()); |
- audio_desc = static_cast<const cricket::AudioContentDescription*>( |
- audio_content->description); |
- EXPECT_FALSE( |
- ContainsTrack(audio_desc->streams(), kStreamLabel1, "audio_track")); |
- |
- video_content = cricket::GetFirstVideoContent(offer->description()); |
- video_desc = static_cast<const cricket::VideoContentDescription*>( |
- video_content->description); |
- EXPECT_FALSE( |
- ContainsTrack(video_desc->streams(), kStreamLabel1, "video_track")); |
- |
- EXPECT_TRUE(DoSetLocalDescription(offer.release())); |
- |
- // Calling RemoveTrack on a sender no longer attached to a PeerConnection |
- // should return false. |
- EXPECT_FALSE(pc_->RemoveTrack(audio_sender)); |
- EXPECT_FALSE(pc_->RemoveTrack(video_sender)); |
-} |
- |
-// Test creating senders without a stream specified, |
-// expecting a random stream ID to be generated. |
-TEST_F(PeerConnectionInterfaceTest, AddTrackWithoutStream) { |
- CreatePeerConnectionWithoutDtls(); |
- // Create a dummy stream, so tracks share a stream label. |
- rtc::scoped_refptr<AudioTrackInterface> audio_track( |
- pc_factory_->CreateAudioTrack("audio_track", nullptr)); |
- rtc::scoped_refptr<VideoTrackInterface> video_track( |
- pc_factory_->CreateVideoTrack( |
- "video_track", |
- pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer()))); |
- auto audio_sender = |
- pc_->AddTrack(audio_track, std::vector<MediaStreamInterface*>()); |
- auto video_sender = |
- pc_->AddTrack(video_track, std::vector<MediaStreamInterface*>()); |
- EXPECT_EQ("audio_track", audio_sender->id()); |
- EXPECT_EQ(audio_track, audio_sender->track()); |
- EXPECT_EQ("video_track", video_sender->id()); |
- EXPECT_EQ(video_track, video_sender->track()); |
- // If the ID is truly a random GUID, it should be infinitely unlikely they |
- // will be the same. |
- EXPECT_NE(video_sender->stream_ids(), audio_sender->stream_ids()); |
-} |
- |
-TEST_F(PeerConnectionInterfaceTest, CreateOfferReceiveAnswer) { |
- InitiateCall(); |
- WaitAndVerifyOnAddStream(kStreamLabel1); |
- VerifyRemoteRtpHeaderExtensions(); |
-} |
- |
-TEST_F(PeerConnectionInterfaceTest, CreateOfferReceivePrAnswerAndAnswer) { |
- CreatePeerConnectionWithoutDtls(); |
- AddVideoStream(kStreamLabel1); |
- CreateOfferAsLocalDescription(); |
- std::string offer; |
- EXPECT_TRUE(pc_->local_description()->ToString(&offer)); |
- CreatePrAnswerAndAnswerAsRemoteDescription(offer); |
- WaitAndVerifyOnAddStream(kStreamLabel1); |
-} |
- |
-TEST_F(PeerConnectionInterfaceTest, ReceiveOfferCreateAnswer) { |
- CreatePeerConnectionWithoutDtls(); |
- AddVideoStream(kStreamLabel1); |
- |
- CreateOfferAsRemoteDescription(); |
- CreateAnswerAsLocalDescription(); |
- |
- WaitAndVerifyOnAddStream(kStreamLabel1); |
-} |
- |
-TEST_F(PeerConnectionInterfaceTest, ReceiveOfferCreatePrAnswerAndAnswer) { |
- CreatePeerConnectionWithoutDtls(); |
- AddVideoStream(kStreamLabel1); |
- |
- CreateOfferAsRemoteDescription(); |
- CreatePrAnswerAsLocalDescription(); |
- CreateAnswerAsLocalDescription(); |
- |
- WaitAndVerifyOnAddStream(kStreamLabel1); |
-} |
- |
-TEST_F(PeerConnectionInterfaceTest, Renegotiate) { |
- InitiateCall(); |
- ASSERT_EQ(1u, pc_->remote_streams()->count()); |
- pc_->RemoveStream(pc_->local_streams()->at(0)); |
- CreateOfferReceiveAnswer(); |
- EXPECT_EQ(0u, pc_->remote_streams()->count()); |
- AddVideoStream(kStreamLabel1); |
- CreateOfferReceiveAnswer(); |
-} |
- |
-// Tests that after negotiating an audio only call, the respondent can perform a |
-// renegotiation that removes the audio stream. |
-TEST_F(PeerConnectionInterfaceTest, RenegotiateAudioOnly) { |
- CreatePeerConnectionWithoutDtls(); |
- AddVoiceStream(kStreamLabel1); |
- CreateOfferAsRemoteDescription(); |
- CreateAnswerAsLocalDescription(); |
- |
- ASSERT_EQ(1u, pc_->remote_streams()->count()); |
- pc_->RemoveStream(pc_->local_streams()->at(0)); |
- CreateOfferReceiveAnswer(); |
- EXPECT_EQ(0u, pc_->remote_streams()->count()); |
-} |
- |
-// Test that candidates are generated and that we can parse our own candidates. |
-TEST_F(PeerConnectionInterfaceTest, IceCandidates) { |
- CreatePeerConnectionWithoutDtls(); |
- |
- EXPECT_FALSE(pc_->AddIceCandidate(observer_.last_candidate_.get())); |
- // SetRemoteDescription takes ownership of offer. |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- AddVideoStream(kStreamLabel1); |
- EXPECT_TRUE(DoCreateOffer(&offer, nullptr)); |
- EXPECT_TRUE(DoSetRemoteDescription(offer.release())); |
- |
- // SetLocalDescription takes ownership of answer. |
- std::unique_ptr<SessionDescriptionInterface> answer; |
- EXPECT_TRUE(DoCreateAnswer(&answer, nullptr)); |
- EXPECT_TRUE(DoSetLocalDescription(answer.release())); |
- |
- EXPECT_TRUE_WAIT(observer_.last_candidate_.get() != NULL, kTimeout); |
- EXPECT_TRUE_WAIT(observer_.ice_complete_, kTimeout); |
- |
- EXPECT_TRUE(pc_->AddIceCandidate(observer_.last_candidate_.get())); |
-} |
- |
-// Test that CreateOffer and CreateAnswer will fail if the track labels are |
-// not unique. |
-TEST_F(PeerConnectionInterfaceTest, CreateOfferAnswerWithInvalidStream) { |
- CreatePeerConnectionWithoutDtls(); |
- // Create a regular offer for the CreateAnswer test later. |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- EXPECT_TRUE(DoCreateOffer(&offer, nullptr)); |
- EXPECT_TRUE(offer); |
- offer.reset(); |
- |
- // Create a local stream with audio&video tracks having same label. |
- AddAudioVideoStream(kStreamLabel1, "track_label", "track_label"); |
- |
- // Test CreateOffer |
- EXPECT_FALSE(DoCreateOffer(&offer, nullptr)); |
- |
- // Test CreateAnswer |
- std::unique_ptr<SessionDescriptionInterface> answer; |
- EXPECT_FALSE(DoCreateAnswer(&answer, nullptr)); |
-} |
- |
-// Test that we will get different SSRCs for each tracks in the offer and answer |
-// we created. |
-TEST_F(PeerConnectionInterfaceTest, SsrcInOfferAnswer) { |
- CreatePeerConnectionWithoutDtls(); |
- // Create a local stream with audio&video tracks having different labels. |
- AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label"); |
- |
- // Test CreateOffer |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- int audio_ssrc = 0; |
- int video_ssrc = 0; |
- EXPECT_TRUE(GetFirstSsrc(GetFirstAudioContent(offer->description()), |
- &audio_ssrc)); |
- EXPECT_TRUE(GetFirstSsrc(GetFirstVideoContent(offer->description()), |
- &video_ssrc)); |
- EXPECT_NE(audio_ssrc, video_ssrc); |
- |
- // Test CreateAnswer |
- EXPECT_TRUE(DoSetRemoteDescription(offer.release())); |
- std::unique_ptr<SessionDescriptionInterface> answer; |
- ASSERT_TRUE(DoCreateAnswer(&answer, nullptr)); |
- audio_ssrc = 0; |
- video_ssrc = 0; |
- EXPECT_TRUE(GetFirstSsrc(GetFirstAudioContent(answer->description()), |
- &audio_ssrc)); |
- EXPECT_TRUE(GetFirstSsrc(GetFirstVideoContent(answer->description()), |
- &video_ssrc)); |
- EXPECT_NE(audio_ssrc, video_ssrc); |
-} |
- |
-// Test that it's possible to call AddTrack on a MediaStream after adding |
-// the stream to a PeerConnection. |
-// TODO(deadbeef): Remove this test once this behavior is no longer supported. |
-TEST_F(PeerConnectionInterfaceTest, AddTrackAfterAddStream) { |
- CreatePeerConnectionWithoutDtls(); |
- // Create audio stream and add to PeerConnection. |
- AddVoiceStream(kStreamLabel1); |
- MediaStreamInterface* stream = pc_->local_streams()->at(0); |
- |
- // Add video track to the audio-only stream. |
- rtc::scoped_refptr<VideoTrackInterface> video_track( |
- pc_factory_->CreateVideoTrack( |
- "video_label", |
- pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer()))); |
- stream->AddTrack(video_track.get()); |
- |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- |
- const cricket::MediaContentDescription* video_desc = |
- cricket::GetFirstVideoContentDescription(offer->description()); |
- EXPECT_TRUE(video_desc != nullptr); |
-} |
- |
-// Test that it's possible to call RemoveTrack on a MediaStream after adding |
-// the stream to a PeerConnection. |
-// TODO(deadbeef): Remove this test once this behavior is no longer supported. |
-TEST_F(PeerConnectionInterfaceTest, RemoveTrackAfterAddStream) { |
- CreatePeerConnectionWithoutDtls(); |
- // Create audio/video stream and add to PeerConnection. |
- AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label"); |
- MediaStreamInterface* stream = pc_->local_streams()->at(0); |
- |
- // Remove the video track. |
- stream->RemoveTrack(stream->GetVideoTracks()[0]); |
- |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- |
- const cricket::MediaContentDescription* video_desc = |
- cricket::GetFirstVideoContentDescription(offer->description()); |
- EXPECT_TRUE(video_desc == nullptr); |
-} |
- |
-// Test creating a sender with a stream ID, and ensure the ID is populated |
-// in the offer. |
-TEST_F(PeerConnectionInterfaceTest, CreateSenderWithStream) { |
- CreatePeerConnectionWithoutDtls(); |
- pc_->CreateSender("video", kStreamLabel1); |
- |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- |
- const cricket::MediaContentDescription* video_desc = |
- cricket::GetFirstVideoContentDescription(offer->description()); |
- ASSERT_TRUE(video_desc != nullptr); |
- ASSERT_EQ(1u, video_desc->streams().size()); |
- EXPECT_EQ(kStreamLabel1, video_desc->streams()[0].sync_label); |
-} |
- |
-// Test that we can specify a certain track that we want statistics about. |
-TEST_F(PeerConnectionInterfaceTest, GetStatsForSpecificTrack) { |
- InitiateCall(); |
- ASSERT_LT(0u, pc_->remote_streams()->count()); |
- ASSERT_LT(0u, pc_->remote_streams()->at(0)->GetAudioTracks().size()); |
- rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio = |
- pc_->remote_streams()->at(0)->GetAudioTracks()[0]; |
- EXPECT_TRUE(DoGetStats(remote_audio)); |
- |
- // Remove the stream. Since we are sending to our selves the local |
- // and the remote stream is the same. |
- pc_->RemoveStream(pc_->local_streams()->at(0)); |
- // Do a re-negotiation. |
- CreateOfferReceiveAnswer(); |
- |
- ASSERT_EQ(0u, pc_->remote_streams()->count()); |
- |
- // Test that we still can get statistics for the old track. Even if it is not |
- // sent any longer. |
- EXPECT_TRUE(DoGetStats(remote_audio)); |
-} |
- |
-// Test that we can get stats on a video track. |
-TEST_F(PeerConnectionInterfaceTest, GetStatsForVideoTrack) { |
- InitiateCall(); |
- ASSERT_LT(0u, pc_->remote_streams()->count()); |
- ASSERT_LT(0u, pc_->remote_streams()->at(0)->GetVideoTracks().size()); |
- rtc::scoped_refptr<MediaStreamTrackInterface> remote_video = |
- pc_->remote_streams()->at(0)->GetVideoTracks()[0]; |
- EXPECT_TRUE(DoGetStats(remote_video)); |
-} |
- |
-// Test that we don't get statistics for an invalid track. |
-TEST_F(PeerConnectionInterfaceTest, GetStatsForInvalidTrack) { |
- InitiateCall(); |
- rtc::scoped_refptr<AudioTrackInterface> unknown_audio_track( |
- pc_factory_->CreateAudioTrack("unknown track", NULL)); |
- EXPECT_FALSE(DoGetStats(unknown_audio_track)); |
-} |
- |
-// This test setup two RTP data channels in loop back. |
-TEST_F(PeerConnectionInterfaceTest, TestDataChannel) { |
- FakeConstraints constraints; |
- constraints.SetAllowRtpDataChannels(); |
- CreatePeerConnection(&constraints); |
- rtc::scoped_refptr<DataChannelInterface> data1 = |
- pc_->CreateDataChannel("test1", NULL); |
- rtc::scoped_refptr<DataChannelInterface> data2 = |
- pc_->CreateDataChannel("test2", NULL); |
- ASSERT_TRUE(data1 != NULL); |
- std::unique_ptr<MockDataChannelObserver> observer1( |
- new MockDataChannelObserver(data1)); |
- std::unique_ptr<MockDataChannelObserver> observer2( |
- new MockDataChannelObserver(data2)); |
- |
- EXPECT_EQ(DataChannelInterface::kConnecting, data1->state()); |
- EXPECT_EQ(DataChannelInterface::kConnecting, data2->state()); |
- std::string data_to_send1 = "testing testing"; |
- std::string data_to_send2 = "testing something else"; |
- EXPECT_FALSE(data1->Send(DataBuffer(data_to_send1))); |
- |
- CreateOfferReceiveAnswer(); |
- EXPECT_TRUE_WAIT(observer1->IsOpen(), kTimeout); |
- EXPECT_TRUE_WAIT(observer2->IsOpen(), kTimeout); |
- |
- EXPECT_EQ(DataChannelInterface::kOpen, data1->state()); |
- EXPECT_EQ(DataChannelInterface::kOpen, data2->state()); |
- EXPECT_TRUE(data1->Send(DataBuffer(data_to_send1))); |
- EXPECT_TRUE(data2->Send(DataBuffer(data_to_send2))); |
- |
- EXPECT_EQ_WAIT(data_to_send1, observer1->last_message(), kTimeout); |
- EXPECT_EQ_WAIT(data_to_send2, observer2->last_message(), kTimeout); |
- |
- data1->Close(); |
- EXPECT_EQ(DataChannelInterface::kClosing, data1->state()); |
- CreateOfferReceiveAnswer(); |
- EXPECT_FALSE(observer1->IsOpen()); |
- EXPECT_EQ(DataChannelInterface::kClosed, data1->state()); |
- EXPECT_TRUE(observer2->IsOpen()); |
- |
- data_to_send2 = "testing something else again"; |
- EXPECT_TRUE(data2->Send(DataBuffer(data_to_send2))); |
- |
- EXPECT_EQ_WAIT(data_to_send2, observer2->last_message(), kTimeout); |
-} |
- |
-// This test verifies that sendnig binary data over RTP data channels should |
-// fail. |
-TEST_F(PeerConnectionInterfaceTest, TestSendBinaryOnRtpDataChannel) { |
- FakeConstraints constraints; |
- constraints.SetAllowRtpDataChannels(); |
- CreatePeerConnection(&constraints); |
- rtc::scoped_refptr<DataChannelInterface> data1 = |
- pc_->CreateDataChannel("test1", NULL); |
- rtc::scoped_refptr<DataChannelInterface> data2 = |
- pc_->CreateDataChannel("test2", NULL); |
- ASSERT_TRUE(data1 != NULL); |
- std::unique_ptr<MockDataChannelObserver> observer1( |
- new MockDataChannelObserver(data1)); |
- std::unique_ptr<MockDataChannelObserver> observer2( |
- new MockDataChannelObserver(data2)); |
- |
- EXPECT_EQ(DataChannelInterface::kConnecting, data1->state()); |
- EXPECT_EQ(DataChannelInterface::kConnecting, data2->state()); |
- |
- CreateOfferReceiveAnswer(); |
- EXPECT_TRUE_WAIT(observer1->IsOpen(), kTimeout); |
- EXPECT_TRUE_WAIT(observer2->IsOpen(), kTimeout); |
- |
- EXPECT_EQ(DataChannelInterface::kOpen, data1->state()); |
- EXPECT_EQ(DataChannelInterface::kOpen, data2->state()); |
- |
- rtc::CopyOnWriteBuffer buffer("test", 4); |
- EXPECT_FALSE(data1->Send(DataBuffer(buffer, true))); |
-} |
- |
-// This test setup a RTP data channels in loop back and test that a channel is |
-// opened even if the remote end answer with a zero SSRC. |
-TEST_F(PeerConnectionInterfaceTest, TestSendOnlyDataChannel) { |
- FakeConstraints constraints; |
- constraints.SetAllowRtpDataChannels(); |
- CreatePeerConnection(&constraints); |
- rtc::scoped_refptr<DataChannelInterface> data1 = |
- pc_->CreateDataChannel("test1", NULL); |
- std::unique_ptr<MockDataChannelObserver> observer1( |
- new MockDataChannelObserver(data1)); |
- |
- CreateOfferReceiveAnswerWithoutSsrc(); |
- |
- EXPECT_TRUE_WAIT(observer1->IsOpen(), kTimeout); |
- |
- data1->Close(); |
- EXPECT_EQ(DataChannelInterface::kClosing, data1->state()); |
- CreateOfferReceiveAnswerWithoutSsrc(); |
- EXPECT_EQ(DataChannelInterface::kClosed, data1->state()); |
- EXPECT_FALSE(observer1->IsOpen()); |
-} |
- |
-// This test that if a data channel is added in an answer a receive only channel |
-// channel is created. |
-TEST_F(PeerConnectionInterfaceTest, TestReceiveOnlyDataChannel) { |
- FakeConstraints constraints; |
- constraints.SetAllowRtpDataChannels(); |
- CreatePeerConnection(&constraints); |
- |
- std::string offer_label = "offer_channel"; |
- rtc::scoped_refptr<DataChannelInterface> offer_channel = |
- pc_->CreateDataChannel(offer_label, NULL); |
- |
- CreateOfferAsLocalDescription(); |
- |
- // Replace the data channel label in the offer and apply it as an answer. |
- std::string receive_label = "answer_channel"; |
- std::string sdp; |
- EXPECT_TRUE(pc_->local_description()->ToString(&sdp)); |
- rtc::replace_substrs(offer_label.c_str(), offer_label.length(), |
- receive_label.c_str(), receive_label.length(), |
- &sdp); |
- CreateAnswerAsRemoteDescription(sdp); |
- |
- // Verify that a new incoming data channel has been created and that |
- // it is open but can't we written to. |
- ASSERT_TRUE(observer_.last_datachannel_ != NULL); |
- DataChannelInterface* received_channel = observer_.last_datachannel_; |
- EXPECT_EQ(DataChannelInterface::kConnecting, received_channel->state()); |
- EXPECT_EQ(receive_label, received_channel->label()); |
- EXPECT_FALSE(received_channel->Send(DataBuffer("something"))); |
- |
- // Verify that the channel we initially offered has been rejected. |
- EXPECT_EQ(DataChannelInterface::kClosed, offer_channel->state()); |
- |
- // Do another offer / answer exchange and verify that the data channel is |
- // opened. |
- CreateOfferReceiveAnswer(); |
- EXPECT_EQ_WAIT(DataChannelInterface::kOpen, received_channel->state(), |
- kTimeout); |
-} |
- |
-// This test that no data channel is returned if a reliable channel is |
-// requested. |
-// TODO(perkj): Remove this test once reliable channels are implemented. |
-TEST_F(PeerConnectionInterfaceTest, CreateReliableRtpDataChannelShouldFail) { |
- FakeConstraints constraints; |
- constraints.SetAllowRtpDataChannels(); |
- CreatePeerConnection(&constraints); |
- |
- std::string label = "test"; |
- webrtc::DataChannelInit config; |
- config.reliable = true; |
- rtc::scoped_refptr<DataChannelInterface> channel = |
- pc_->CreateDataChannel(label, &config); |
- EXPECT_TRUE(channel == NULL); |
-} |
- |
-// Verifies that duplicated label is not allowed for RTP data channel. |
-TEST_F(PeerConnectionInterfaceTest, RtpDuplicatedLabelNotAllowed) { |
- FakeConstraints constraints; |
- constraints.SetAllowRtpDataChannels(); |
- CreatePeerConnection(&constraints); |
- |
- std::string label = "test"; |
- rtc::scoped_refptr<DataChannelInterface> channel = |
- pc_->CreateDataChannel(label, nullptr); |
- EXPECT_NE(channel, nullptr); |
- |
- rtc::scoped_refptr<DataChannelInterface> dup_channel = |
- pc_->CreateDataChannel(label, nullptr); |
- EXPECT_EQ(dup_channel, nullptr); |
-} |
- |
-// This tests that a SCTP data channel is returned using different |
-// DataChannelInit configurations. |
-TEST_F(PeerConnectionInterfaceTest, CreateSctpDataChannel) { |
- FakeConstraints constraints; |
- constraints.SetAllowDtlsSctpDataChannels(); |
- CreatePeerConnection(&constraints); |
- |
- webrtc::DataChannelInit config; |
- |
- rtc::scoped_refptr<DataChannelInterface> channel = |
- pc_->CreateDataChannel("1", &config); |
- EXPECT_TRUE(channel != NULL); |
- EXPECT_TRUE(channel->reliable()); |
- EXPECT_TRUE(observer_.renegotiation_needed_); |
- observer_.renegotiation_needed_ = false; |
- |
- config.ordered = false; |
- channel = pc_->CreateDataChannel("2", &config); |
- EXPECT_TRUE(channel != NULL); |
- EXPECT_TRUE(channel->reliable()); |
- EXPECT_FALSE(observer_.renegotiation_needed_); |
- |
- config.ordered = true; |
- config.maxRetransmits = 0; |
- channel = pc_->CreateDataChannel("3", &config); |
- EXPECT_TRUE(channel != NULL); |
- EXPECT_FALSE(channel->reliable()); |
- EXPECT_FALSE(observer_.renegotiation_needed_); |
- |
- config.maxRetransmits = -1; |
- config.maxRetransmitTime = 0; |
- channel = pc_->CreateDataChannel("4", &config); |
- EXPECT_TRUE(channel != NULL); |
- EXPECT_FALSE(channel->reliable()); |
- EXPECT_FALSE(observer_.renegotiation_needed_); |
-} |
- |
-// This tests that no data channel is returned if both maxRetransmits and |
-// maxRetransmitTime are set for SCTP data channels. |
-TEST_F(PeerConnectionInterfaceTest, |
- CreateSctpDataChannelShouldFailForInvalidConfig) { |
- FakeConstraints constraints; |
- constraints.SetAllowDtlsSctpDataChannels(); |
- CreatePeerConnection(&constraints); |
- |
- std::string label = "test"; |
- webrtc::DataChannelInit config; |
- config.maxRetransmits = 0; |
- config.maxRetransmitTime = 0; |
- |
- rtc::scoped_refptr<DataChannelInterface> channel = |
- pc_->CreateDataChannel(label, &config); |
- EXPECT_TRUE(channel == NULL); |
-} |
- |
-// The test verifies that creating a SCTP data channel with an id already in use |
-// or out of range should fail. |
-TEST_F(PeerConnectionInterfaceTest, |
- CreateSctpDataChannelWithInvalidIdShouldFail) { |
- FakeConstraints constraints; |
- constraints.SetAllowDtlsSctpDataChannels(); |
- CreatePeerConnection(&constraints); |
- |
- webrtc::DataChannelInit config; |
- rtc::scoped_refptr<DataChannelInterface> channel; |
- |
- config.id = 1; |
- channel = pc_->CreateDataChannel("1", &config); |
- EXPECT_TRUE(channel != NULL); |
- EXPECT_EQ(1, channel->id()); |
- |
- channel = pc_->CreateDataChannel("x", &config); |
- EXPECT_TRUE(channel == NULL); |
- |
- config.id = cricket::kMaxSctpSid; |
- channel = pc_->CreateDataChannel("max", &config); |
- EXPECT_TRUE(channel != NULL); |
- EXPECT_EQ(config.id, channel->id()); |
- |
- config.id = cricket::kMaxSctpSid + 1; |
- channel = pc_->CreateDataChannel("x", &config); |
- EXPECT_TRUE(channel == NULL); |
-} |
- |
-// Verifies that duplicated label is allowed for SCTP data channel. |
-TEST_F(PeerConnectionInterfaceTest, SctpDuplicatedLabelAllowed) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- |
- std::string label = "test"; |
- rtc::scoped_refptr<DataChannelInterface> channel = |
- pc_->CreateDataChannel(label, nullptr); |
- EXPECT_NE(channel, nullptr); |
- |
- rtc::scoped_refptr<DataChannelInterface> dup_channel = |
- pc_->CreateDataChannel(label, nullptr); |
- EXPECT_NE(dup_channel, nullptr); |
-} |
- |
-// This test verifies that OnRenegotiationNeeded is fired for every new RTP |
-// DataChannel. |
-TEST_F(PeerConnectionInterfaceTest, RenegotiationNeededForNewRtpDataChannel) { |
- FakeConstraints constraints; |
- constraints.SetAllowRtpDataChannels(); |
- CreatePeerConnection(&constraints); |
- |
- rtc::scoped_refptr<DataChannelInterface> dc1 = |
- pc_->CreateDataChannel("test1", NULL); |
- EXPECT_TRUE(observer_.renegotiation_needed_); |
- observer_.renegotiation_needed_ = false; |
- |
- rtc::scoped_refptr<DataChannelInterface> dc2 = |
- pc_->CreateDataChannel("test2", NULL); |
- EXPECT_TRUE(observer_.renegotiation_needed_); |
-} |
- |
-// This test that a data channel closes when a PeerConnection is deleted/closed. |
-TEST_F(PeerConnectionInterfaceTest, DataChannelCloseWhenPeerConnectionClose) { |
- FakeConstraints constraints; |
- constraints.SetAllowRtpDataChannels(); |
- CreatePeerConnection(&constraints); |
- |
- rtc::scoped_refptr<DataChannelInterface> data1 = |
- pc_->CreateDataChannel("test1", NULL); |
- rtc::scoped_refptr<DataChannelInterface> data2 = |
- pc_->CreateDataChannel("test2", NULL); |
- ASSERT_TRUE(data1 != NULL); |
- std::unique_ptr<MockDataChannelObserver> observer1( |
- new MockDataChannelObserver(data1)); |
- std::unique_ptr<MockDataChannelObserver> observer2( |
- new MockDataChannelObserver(data2)); |
- |
- CreateOfferReceiveAnswer(); |
- EXPECT_TRUE_WAIT(observer1->IsOpen(), kTimeout); |
- EXPECT_TRUE_WAIT(observer2->IsOpen(), kTimeout); |
- |
- ReleasePeerConnection(); |
- EXPECT_EQ(DataChannelInterface::kClosed, data1->state()); |
- EXPECT_EQ(DataChannelInterface::kClosed, data2->state()); |
-} |
- |
-// This test that data channels can be rejected in an answer. |
-TEST_F(PeerConnectionInterfaceTest, TestRejectDataChannelInAnswer) { |
- FakeConstraints constraints; |
- constraints.SetAllowRtpDataChannels(); |
- CreatePeerConnection(&constraints); |
- |
- rtc::scoped_refptr<DataChannelInterface> offer_channel( |
- pc_->CreateDataChannel("offer_channel", NULL)); |
- |
- CreateOfferAsLocalDescription(); |
- |
- // Create an answer where the m-line for data channels are rejected. |
- std::string sdp; |
- EXPECT_TRUE(pc_->local_description()->ToString(&sdp)); |
- webrtc::JsepSessionDescription* answer = new webrtc::JsepSessionDescription( |
- SessionDescriptionInterface::kAnswer); |
- EXPECT_TRUE(answer->Initialize(sdp, NULL)); |
- cricket::ContentInfo* data_info = |
- answer->description()->GetContentByName("data"); |
- data_info->rejected = true; |
- |
- DoSetRemoteDescription(answer); |
- EXPECT_EQ(DataChannelInterface::kClosed, offer_channel->state()); |
-} |
- |
-// Test that we can create a session description from an SDP string from |
-// FireFox, use it as a remote session description, generate an answer and use |
-// the answer as a local description. |
-TEST_F(PeerConnectionInterfaceTest, ReceiveFireFoxOffer) { |
- MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label"); |
- SessionDescriptionInterface* desc = |
- webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer, |
- webrtc::kFireFoxSdpOffer, nullptr); |
- EXPECT_TRUE(DoSetSessionDescription(desc, false)); |
- CreateAnswerAsLocalDescription(); |
- ASSERT_TRUE(pc_->local_description() != NULL); |
- ASSERT_TRUE(pc_->remote_description() != NULL); |
- |
- const cricket::ContentInfo* content = |
- cricket::GetFirstAudioContent(pc_->local_description()->description()); |
- ASSERT_TRUE(content != NULL); |
- EXPECT_FALSE(content->rejected); |
- |
- content = |
- cricket::GetFirstVideoContent(pc_->local_description()->description()); |
- ASSERT_TRUE(content != NULL); |
- EXPECT_FALSE(content->rejected); |
-#ifdef HAVE_SCTP |
- content = |
- cricket::GetFirstDataContent(pc_->local_description()->description()); |
- ASSERT_TRUE(content != NULL); |
- EXPECT_TRUE(content->rejected); |
-#endif |
-} |
- |
-// Test that an offer can be received which offers DTLS with SDES fallback. |
-// Regression test for issue: |
-// https://bugs.chromium.org/p/webrtc/issues/detail?id=6972 |
-TEST_F(PeerConnectionInterfaceTest, ReceiveDtlsSdesFallbackOffer) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- // Wait for fake certificate to be generated. Previously, this is what caused |
- // the "a=crypto" lines to be rejected. |
- AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label"); |
- ASSERT_NE(nullptr, fake_certificate_generator_); |
- EXPECT_EQ_WAIT(1, fake_certificate_generator_->generated_certificates(), |
- kTimeout); |
- SessionDescriptionInterface* desc = webrtc::CreateSessionDescription( |
- SessionDescriptionInterface::kOffer, kDtlsSdesFallbackSdp, nullptr); |
- EXPECT_TRUE(DoSetSessionDescription(desc, false)); |
- CreateAnswerAsLocalDescription(); |
-} |
- |
-// Test that we can create an audio only offer and receive an answer with a |
-// limited set of audio codecs and receive an updated offer with more audio |
-// codecs, where the added codecs are not supported. |
-TEST_F(PeerConnectionInterfaceTest, ReceiveUpdatedAudioOfferWithBadCodecs) { |
- CreatePeerConnectionWithoutDtls(); |
- AddVoiceStream("audio_label"); |
- CreateOfferAsLocalDescription(); |
- |
- SessionDescriptionInterface* answer = |
- webrtc::CreateSessionDescription(SessionDescriptionInterface::kAnswer, |
- webrtc::kAudioSdp, nullptr); |
- EXPECT_TRUE(DoSetSessionDescription(answer, false)); |
- |
- SessionDescriptionInterface* updated_offer = |
- webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer, |
- webrtc::kAudioSdpWithUnsupportedCodecs, |
- nullptr); |
- EXPECT_TRUE(DoSetSessionDescription(updated_offer, false)); |
- CreateAnswerAsLocalDescription(); |
-} |
- |
-// Test that if we're receiving (but not sending) a track, subsequent offers |
-// will have m-lines with a=recvonly. |
-TEST_F(PeerConnectionInterfaceTest, CreateSubsequentRecvOnlyOffer) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- CreateAndSetRemoteOffer(kSdpStringWithStream1); |
- CreateAnswerAsLocalDescription(); |
- |
- // At this point we should be receiving stream 1, but not sending anything. |
- // A new offer should be recvonly. |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- DoCreateOffer(&offer, nullptr); |
- |
- const cricket::ContentInfo* video_content = |
- cricket::GetFirstVideoContent(offer->description()); |
- const cricket::VideoContentDescription* video_desc = |
- static_cast<const cricket::VideoContentDescription*>( |
- video_content->description); |
- ASSERT_EQ(cricket::MD_RECVONLY, video_desc->direction()); |
- |
- const cricket::ContentInfo* audio_content = |
- cricket::GetFirstAudioContent(offer->description()); |
- const cricket::AudioContentDescription* audio_desc = |
- static_cast<const cricket::AudioContentDescription*>( |
- audio_content->description); |
- ASSERT_EQ(cricket::MD_RECVONLY, audio_desc->direction()); |
-} |
- |
-// Test that if we're receiving (but not sending) a track, and the |
-// offerToReceiveVideo/offerToReceiveAudio constraints are explicitly set to |
-// false, the generated m-lines will be a=inactive. |
-TEST_F(PeerConnectionInterfaceTest, CreateSubsequentInactiveOffer) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- CreateAndSetRemoteOffer(kSdpStringWithStream1); |
- CreateAnswerAsLocalDescription(); |
- |
- // At this point we should be receiving stream 1, but not sending anything. |
- // A new offer would be recvonly, but we'll set the "no receive" constraints |
- // to make it inactive. |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- FakeConstraints offer_constraints; |
- offer_constraints.AddMandatory( |
- webrtc::MediaConstraintsInterface::kOfferToReceiveVideo, false); |
- offer_constraints.AddMandatory( |
- webrtc::MediaConstraintsInterface::kOfferToReceiveAudio, false); |
- DoCreateOffer(&offer, &offer_constraints); |
- |
- const cricket::ContentInfo* video_content = |
- cricket::GetFirstVideoContent(offer->description()); |
- const cricket::VideoContentDescription* video_desc = |
- static_cast<const cricket::VideoContentDescription*>( |
- video_content->description); |
- ASSERT_EQ(cricket::MD_INACTIVE, video_desc->direction()); |
- |
- const cricket::ContentInfo* audio_content = |
- cricket::GetFirstAudioContent(offer->description()); |
- const cricket::AudioContentDescription* audio_desc = |
- static_cast<const cricket::AudioContentDescription*>( |
- audio_content->description); |
- ASSERT_EQ(cricket::MD_INACTIVE, audio_desc->direction()); |
-} |
- |
-// Test that we can use SetConfiguration to change the ICE servers of the |
-// PortAllocator. |
-TEST_F(PeerConnectionInterfaceTest, SetConfigurationChangesIceServers) { |
- CreatePeerConnection(); |
- |
- PeerConnectionInterface::RTCConfiguration config; |
- PeerConnectionInterface::IceServer server; |
- server.uri = "stun:test_hostname"; |
- config.servers.push_back(server); |
- EXPECT_TRUE(pc_->SetConfiguration(config)); |
- |
- EXPECT_EQ(1u, port_allocator_->stun_servers().size()); |
- EXPECT_EQ("test_hostname", |
- port_allocator_->stun_servers().begin()->hostname()); |
-} |
- |
-TEST_F(PeerConnectionInterfaceTest, SetConfigurationChangesCandidateFilter) { |
- CreatePeerConnection(); |
- PeerConnectionInterface::RTCConfiguration config; |
- config.type = PeerConnectionInterface::kRelay; |
- EXPECT_TRUE(pc_->SetConfiguration(config)); |
- EXPECT_EQ(cricket::CF_RELAY, port_allocator_->candidate_filter()); |
-} |
- |
-TEST_F(PeerConnectionInterfaceTest, SetConfigurationChangesPruneTurnPortsFlag) { |
- PeerConnectionInterface::RTCConfiguration config; |
- config.prune_turn_ports = false; |
- CreatePeerConnection(config, nullptr); |
- EXPECT_FALSE(port_allocator_->prune_turn_ports()); |
- |
- config.prune_turn_ports = true; |
- EXPECT_TRUE(pc_->SetConfiguration(config)); |
- EXPECT_TRUE(port_allocator_->prune_turn_ports()); |
-} |
- |
-// Test that when SetConfiguration changes both the pool size and other |
-// attributes, the pooled session is created with the updated attributes. |
-TEST_F(PeerConnectionInterfaceTest, |
- SetConfigurationCreatesPooledSessionCorrectly) { |
- CreatePeerConnection(); |
- PeerConnectionInterface::RTCConfiguration config; |
- config.ice_candidate_pool_size = 1; |
- PeerConnectionInterface::IceServer server; |
- server.uri = kStunAddressOnly; |
- config.servers.push_back(server); |
- config.type = PeerConnectionInterface::kRelay; |
- EXPECT_TRUE(pc_->SetConfiguration(config)); |
- |
- const cricket::FakePortAllocatorSession* session = |
- static_cast<const cricket::FakePortAllocatorSession*>( |
- port_allocator_->GetPooledSession()); |
- ASSERT_NE(nullptr, session); |
- EXPECT_EQ(1UL, session->stun_servers().size()); |
-} |
- |
-// Test that after SetLocalDescription, changing the pool size is not allowed, |
-// and an invalid modification error is returned. |
-TEST_F(PeerConnectionInterfaceTest, |
- CantChangePoolSizeAfterSetLocalDescription) { |
- CreatePeerConnection(); |
- // Start by setting a size of 1. |
- PeerConnectionInterface::RTCConfiguration config; |
- config.ice_candidate_pool_size = 1; |
- EXPECT_TRUE(pc_->SetConfiguration(config)); |
- |
- // Set remote offer; can still change pool size at this point. |
- CreateOfferAsRemoteDescription(); |
- config.ice_candidate_pool_size = 2; |
- EXPECT_TRUE(pc_->SetConfiguration(config)); |
- |
- // Set local answer; now it's too late. |
- CreateAnswerAsLocalDescription(); |
- config.ice_candidate_pool_size = 3; |
- RTCError error; |
- EXPECT_FALSE(pc_->SetConfiguration(config, &error)); |
- EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, error.type()); |
-} |
- |
-// Test that SetConfiguration returns an invalid modification error if |
-// modifying a field in the configuration that isn't allowed to be modified. |
-TEST_F(PeerConnectionInterfaceTest, |
- SetConfigurationReturnsInvalidModificationError) { |
- PeerConnectionInterface::RTCConfiguration config; |
- config.bundle_policy = PeerConnectionInterface::kBundlePolicyBalanced; |
- config.rtcp_mux_policy = PeerConnectionInterface::kRtcpMuxPolicyNegotiate; |
- config.continual_gathering_policy = PeerConnectionInterface::GATHER_ONCE; |
- CreatePeerConnection(config, nullptr); |
- |
- PeerConnectionInterface::RTCConfiguration modified_config = config; |
- modified_config.bundle_policy = |
- PeerConnectionInterface::kBundlePolicyMaxBundle; |
- RTCError error; |
- EXPECT_FALSE(pc_->SetConfiguration(modified_config, &error)); |
- EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, error.type()); |
- |
- modified_config = config; |
- modified_config.rtcp_mux_policy = |
- PeerConnectionInterface::kRtcpMuxPolicyRequire; |
- error.set_type(RTCErrorType::NONE); |
- EXPECT_FALSE(pc_->SetConfiguration(modified_config, &error)); |
- EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, error.type()); |
- |
- modified_config = config; |
- modified_config.continual_gathering_policy = |
- PeerConnectionInterface::GATHER_CONTINUALLY; |
- error.set_type(RTCErrorType::NONE); |
- EXPECT_FALSE(pc_->SetConfiguration(modified_config, &error)); |
- EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, error.type()); |
-} |
- |
-// Test that SetConfiguration returns a range error if the candidate pool size |
-// is negative or larger than allowed by the spec. |
-TEST_F(PeerConnectionInterfaceTest, |
- SetConfigurationReturnsRangeErrorForBadCandidatePoolSize) { |
- PeerConnectionInterface::RTCConfiguration config; |
- CreatePeerConnection(config, nullptr); |
- |
- config.ice_candidate_pool_size = -1; |
- RTCError error; |
- EXPECT_FALSE(pc_->SetConfiguration(config, &error)); |
- EXPECT_EQ(RTCErrorType::INVALID_RANGE, error.type()); |
- |
- config.ice_candidate_pool_size = INT_MAX; |
- error.set_type(RTCErrorType::NONE); |
- EXPECT_FALSE(pc_->SetConfiguration(config, &error)); |
- EXPECT_EQ(RTCErrorType::INVALID_RANGE, error.type()); |
-} |
- |
-// Test that SetConfiguration returns a syntax error if parsing an ICE server |
-// URL failed. |
-TEST_F(PeerConnectionInterfaceTest, |
- SetConfigurationReturnsSyntaxErrorFromBadIceUrls) { |
- PeerConnectionInterface::RTCConfiguration config; |
- CreatePeerConnection(config, nullptr); |
- |
- PeerConnectionInterface::IceServer bad_server; |
- bad_server.uri = "stunn:www.example.com"; |
- config.servers.push_back(bad_server); |
- RTCError error; |
- EXPECT_FALSE(pc_->SetConfiguration(config, &error)); |
- EXPECT_EQ(RTCErrorType::SYNTAX_ERROR, error.type()); |
-} |
- |
-// Test that SetConfiguration returns an invalid parameter error if a TURN |
-// IceServer is missing a username or password. |
-TEST_F(PeerConnectionInterfaceTest, |
- SetConfigurationReturnsInvalidParameterIfCredentialsMissing) { |
- PeerConnectionInterface::RTCConfiguration config; |
- CreatePeerConnection(config, nullptr); |
- |
- PeerConnectionInterface::IceServer bad_server; |
- bad_server.uri = "turn:www.example.com"; |
- // Missing password. |
- bad_server.username = "foo"; |
- config.servers.push_back(bad_server); |
- RTCError error; |
- EXPECT_FALSE(pc_->SetConfiguration(config, &error)); |
- EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, error.type()); |
-} |
- |
-// Test that PeerConnection::Close changes the states to closed and all remote |
-// tracks change state to ended. |
-TEST_F(PeerConnectionInterfaceTest, CloseAndTestStreamsAndStates) { |
- // Initialize a PeerConnection and negotiate local and remote session |
- // description. |
- InitiateCall(); |
- ASSERT_EQ(1u, pc_->local_streams()->count()); |
- ASSERT_EQ(1u, pc_->remote_streams()->count()); |
- |
- pc_->Close(); |
- |
- EXPECT_EQ(PeerConnectionInterface::kClosed, pc_->signaling_state()); |
- EXPECT_EQ(PeerConnectionInterface::kIceConnectionClosed, |
- pc_->ice_connection_state()); |
- EXPECT_EQ(PeerConnectionInterface::kIceGatheringComplete, |
- pc_->ice_gathering_state()); |
- |
- EXPECT_EQ(1u, pc_->local_streams()->count()); |
- EXPECT_EQ(1u, pc_->remote_streams()->count()); |
- |
- rtc::scoped_refptr<MediaStreamInterface> remote_stream = |
- pc_->remote_streams()->at(0); |
- // Track state may be updated asynchronously. |
- EXPECT_EQ_WAIT(MediaStreamTrackInterface::kEnded, |
- remote_stream->GetAudioTracks()[0]->state(), kTimeout); |
- EXPECT_EQ_WAIT(MediaStreamTrackInterface::kEnded, |
- remote_stream->GetVideoTracks()[0]->state(), kTimeout); |
-} |
- |
-// Test that PeerConnection methods fails gracefully after |
-// PeerConnection::Close has been called. |
-TEST_F(PeerConnectionInterfaceTest, CloseAndTestMethods) { |
- CreatePeerConnectionWithoutDtls(); |
- AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label"); |
- CreateOfferAsRemoteDescription(); |
- CreateAnswerAsLocalDescription(); |
- |
- ASSERT_EQ(1u, pc_->local_streams()->count()); |
- rtc::scoped_refptr<MediaStreamInterface> local_stream = |
- pc_->local_streams()->at(0); |
- |
- pc_->Close(); |
- |
- pc_->RemoveStream(local_stream); |
- EXPECT_FALSE(pc_->AddStream(local_stream)); |
- |
- ASSERT_FALSE(local_stream->GetAudioTracks().empty()); |
- rtc::scoped_refptr<webrtc::DtmfSenderInterface> dtmf_sender( |
- pc_->CreateDtmfSender(local_stream->GetAudioTracks()[0])); |
- EXPECT_TRUE(NULL == dtmf_sender); // local stream has been removed. |
- |
- EXPECT_TRUE(pc_->CreateDataChannel("test", NULL) == NULL); |
- |
- EXPECT_TRUE(pc_->local_description() != NULL); |
- EXPECT_TRUE(pc_->remote_description() != NULL); |
- |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- EXPECT_TRUE(DoCreateOffer(&offer, nullptr)); |
- std::unique_ptr<SessionDescriptionInterface> answer; |
- EXPECT_TRUE(DoCreateAnswer(&answer, nullptr)); |
- |
- std::string sdp; |
- ASSERT_TRUE(pc_->remote_description()->ToString(&sdp)); |
- SessionDescriptionInterface* remote_offer = |
- webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer, |
- sdp, NULL); |
- EXPECT_FALSE(DoSetRemoteDescription(remote_offer)); |
- |
- ASSERT_TRUE(pc_->local_description()->ToString(&sdp)); |
- SessionDescriptionInterface* local_offer = |
- webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer, |
- sdp, NULL); |
- EXPECT_FALSE(DoSetLocalDescription(local_offer)); |
-} |
- |
-// Test that GetStats can still be called after PeerConnection::Close. |
-TEST_F(PeerConnectionInterfaceTest, CloseAndGetStats) { |
- InitiateCall(); |
- pc_->Close(); |
- DoGetStats(NULL); |
-} |
- |
-// NOTE: The series of tests below come from what used to be |
-// mediastreamsignaling_unittest.cc, and are mostly aimed at testing that |
-// setting a remote or local description has the expected effects. |
- |
-// This test verifies that the remote MediaStreams corresponding to a received |
-// SDP string is created. In this test the two separate MediaStreams are |
-// signaled. |
-TEST_F(PeerConnectionInterfaceTest, UpdateRemoteStreams) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- CreateAndSetRemoteOffer(kSdpStringWithStream1); |
- |
- rtc::scoped_refptr<StreamCollection> reference(CreateStreamCollection(1, 1)); |
- EXPECT_TRUE( |
- CompareStreamCollections(observer_.remote_streams(), reference.get())); |
- MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0); |
- EXPECT_TRUE(remote_stream->GetVideoTracks()[0]->GetSource() != nullptr); |
- |
- // Create a session description based on another SDP with another |
- // MediaStream. |
- CreateAndSetRemoteOffer(kSdpStringWithStream1And2); |
- |
- rtc::scoped_refptr<StreamCollection> reference2(CreateStreamCollection(2, 1)); |
- EXPECT_TRUE( |
- CompareStreamCollections(observer_.remote_streams(), reference2.get())); |
-} |
- |
-// This test verifies that when remote tracks are added/removed from SDP, the |
-// created remote streams are updated appropriately. |
-TEST_F(PeerConnectionInterfaceTest, |
- AddRemoveTrackFromExistingRemoteMediaStream) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- std::unique_ptr<SessionDescriptionInterface> desc_ms1 = |
- CreateSessionDescriptionAndReference(1, 1); |
- EXPECT_TRUE(DoSetRemoteDescription(desc_ms1.release())); |
- EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(), |
- reference_collection_)); |
- |
- // Add extra audio and video tracks to the same MediaStream. |
- std::unique_ptr<SessionDescriptionInterface> desc_ms1_two_tracks = |
- CreateSessionDescriptionAndReference(2, 2); |
- EXPECT_TRUE(DoSetRemoteDescription(desc_ms1_two_tracks.release())); |
- EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(), |
- reference_collection_)); |
- rtc::scoped_refptr<AudioTrackInterface> audio_track2 = |
- observer_.remote_streams()->at(0)->GetAudioTracks()[1]; |
- EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, audio_track2->state()); |
- rtc::scoped_refptr<VideoTrackInterface> video_track2 = |
- observer_.remote_streams()->at(0)->GetVideoTracks()[1]; |
- EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, video_track2->state()); |
- |
- // Remove the extra audio and video tracks. |
- std::unique_ptr<SessionDescriptionInterface> desc_ms2 = |
- CreateSessionDescriptionAndReference(1, 1); |
- MockTrackObserver audio_track_observer(audio_track2); |
- MockTrackObserver video_track_observer(video_track2); |
- |
- EXPECT_CALL(audio_track_observer, OnChanged()).Times(Exactly(1)); |
- EXPECT_CALL(video_track_observer, OnChanged()).Times(Exactly(1)); |
- EXPECT_TRUE(DoSetRemoteDescription(desc_ms2.release())); |
- EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(), |
- reference_collection_)); |
- // Track state may be updated asynchronously. |
- EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded, |
- audio_track2->state(), kTimeout); |
- EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded, |
- video_track2->state(), kTimeout); |
-} |
- |
-// This tests that remote tracks are ended if a local session description is set |
-// that rejects the media content type. |
-TEST_F(PeerConnectionInterfaceTest, RejectMediaContent) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- // First create and set a remote offer, then reject its video content in our |
- // answer. |
- CreateAndSetRemoteOffer(kSdpStringWithStream1); |
- ASSERT_EQ(1u, observer_.remote_streams()->count()); |
- MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0); |
- ASSERT_EQ(1u, remote_stream->GetVideoTracks().size()); |
- ASSERT_EQ(1u, remote_stream->GetAudioTracks().size()); |
- |
- rtc::scoped_refptr<webrtc::VideoTrackInterface> remote_video = |
- remote_stream->GetVideoTracks()[0]; |
- EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_video->state()); |
- rtc::scoped_refptr<webrtc::AudioTrackInterface> remote_audio = |
- remote_stream->GetAudioTracks()[0]; |
- EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_audio->state()); |
- |
- std::unique_ptr<SessionDescriptionInterface> local_answer; |
- EXPECT_TRUE(DoCreateAnswer(&local_answer, nullptr)); |
- cricket::ContentInfo* video_info = |
- local_answer->description()->GetContentByName("video"); |
- video_info->rejected = true; |
- EXPECT_TRUE(DoSetLocalDescription(local_answer.release())); |
- EXPECT_EQ(webrtc::MediaStreamTrackInterface::kEnded, remote_video->state()); |
- EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_audio->state()); |
- |
- // Now create an offer where we reject both video and audio. |
- std::unique_ptr<SessionDescriptionInterface> local_offer; |
- EXPECT_TRUE(DoCreateOffer(&local_offer, nullptr)); |
- video_info = local_offer->description()->GetContentByName("video"); |
- ASSERT_TRUE(video_info != nullptr); |
- video_info->rejected = true; |
- cricket::ContentInfo* audio_info = |
- local_offer->description()->GetContentByName("audio"); |
- ASSERT_TRUE(audio_info != nullptr); |
- audio_info->rejected = true; |
- EXPECT_TRUE(DoSetLocalDescription(local_offer.release())); |
- // Track state may be updated asynchronously. |
- EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded, |
- remote_audio->state(), kTimeout); |
- EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded, |
- remote_video->state(), kTimeout); |
-} |
- |
-// This tests that we won't crash if the remote track has been removed outside |
-// of PeerConnection and then PeerConnection tries to reject the track. |
-TEST_F(PeerConnectionInterfaceTest, RemoveTrackThenRejectMediaContent) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- CreateAndSetRemoteOffer(kSdpStringWithStream1); |
- MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0); |
- remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0]); |
- remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]); |
- |
- std::unique_ptr<SessionDescriptionInterface> local_answer( |
- webrtc::CreateSessionDescription(SessionDescriptionInterface::kAnswer, |
- kSdpStringWithStream1, nullptr)); |
- cricket::ContentInfo* video_info = |
- local_answer->description()->GetContentByName("video"); |
- video_info->rejected = true; |
- cricket::ContentInfo* audio_info = |
- local_answer->description()->GetContentByName("audio"); |
- audio_info->rejected = true; |
- EXPECT_TRUE(DoSetLocalDescription(local_answer.release())); |
- |
- // No crash is a pass. |
-} |
- |
-// This tests that if a recvonly remote description is set, no remote streams |
-// will be created, even if the description contains SSRCs/MSIDs. |
-// See: https://code.google.com/p/webrtc/issues/detail?id=5054 |
-TEST_F(PeerConnectionInterfaceTest, RecvonlyDescriptionDoesntCreateStream) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- |
- std::string recvonly_offer = kSdpStringWithStream1; |
- rtc::replace_substrs(kSendrecv, strlen(kSendrecv), kRecvonly, |
- strlen(kRecvonly), &recvonly_offer); |
- CreateAndSetRemoteOffer(recvonly_offer); |
- |
- EXPECT_EQ(0u, observer_.remote_streams()->count()); |
-} |
- |
-// This tests that a default MediaStream is created if a remote session |
-// description doesn't contain any streams and no MSID support. |
-// It also tests that the default stream is updated if a video m-line is added |
-// in a subsequent session description. |
-TEST_F(PeerConnectionInterfaceTest, SdpWithoutMsidCreatesDefaultStream) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- CreateAndSetRemoteOffer(kSdpStringWithoutStreamsAudioOnly); |
- |
- ASSERT_EQ(1u, observer_.remote_streams()->count()); |
- MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0); |
- |
- EXPECT_EQ(1u, remote_stream->GetAudioTracks().size()); |
- EXPECT_EQ(0u, remote_stream->GetVideoTracks().size()); |
- EXPECT_EQ("default", remote_stream->label()); |
- |
- CreateAndSetRemoteOffer(kSdpStringWithoutStreams); |
- ASSERT_EQ(1u, observer_.remote_streams()->count()); |
- ASSERT_EQ(1u, remote_stream->GetAudioTracks().size()); |
- EXPECT_EQ("defaulta0", remote_stream->GetAudioTracks()[0]->id()); |
- EXPECT_EQ(MediaStreamTrackInterface::kLive, |
- remote_stream->GetAudioTracks()[0]->state()); |
- ASSERT_EQ(1u, remote_stream->GetVideoTracks().size()); |
- EXPECT_EQ("defaultv0", remote_stream->GetVideoTracks()[0]->id()); |
- EXPECT_EQ(MediaStreamTrackInterface::kLive, |
- remote_stream->GetVideoTracks()[0]->state()); |
-} |
- |
-// This tests that a default MediaStream is created if a remote session |
-// description doesn't contain any streams and media direction is send only. |
-TEST_F(PeerConnectionInterfaceTest, |
- SendOnlySdpWithoutMsidCreatesDefaultStream) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- CreateAndSetRemoteOffer(kSdpStringSendOnlyWithoutStreams); |
- |
- ASSERT_EQ(1u, observer_.remote_streams()->count()); |
- MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0); |
- |
- EXPECT_EQ(1u, remote_stream->GetAudioTracks().size()); |
- EXPECT_EQ(1u, remote_stream->GetVideoTracks().size()); |
- EXPECT_EQ("default", remote_stream->label()); |
-} |
- |
-// This tests that it won't crash when PeerConnection tries to remove |
-// a remote track that as already been removed from the MediaStream. |
-TEST_F(PeerConnectionInterfaceTest, RemoveAlreadyGoneRemoteStream) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- CreateAndSetRemoteOffer(kSdpStringWithStream1); |
- MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0); |
- remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]); |
- remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0]); |
- |
- CreateAndSetRemoteOffer(kSdpStringWithoutStreams); |
- |
- // No crash is a pass. |
-} |
- |
-// This tests that a default MediaStream is created if the remote session |
-// description doesn't contain any streams and don't contain an indication if |
-// MSID is supported. |
-TEST_F(PeerConnectionInterfaceTest, |
- SdpWithoutMsidAndStreamsCreatesDefaultStream) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- CreateAndSetRemoteOffer(kSdpStringWithoutStreams); |
- |
- ASSERT_EQ(1u, observer_.remote_streams()->count()); |
- MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0); |
- EXPECT_EQ(1u, remote_stream->GetAudioTracks().size()); |
- EXPECT_EQ(1u, remote_stream->GetVideoTracks().size()); |
-} |
- |
-// This tests that a default MediaStream is not created if the remote session |
-// description doesn't contain any streams but does support MSID. |
-TEST_F(PeerConnectionInterfaceTest, SdpWithMsidDontCreatesDefaultStream) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- CreateAndSetRemoteOffer(kSdpStringWithMsidWithoutStreams); |
- EXPECT_EQ(0u, observer_.remote_streams()->count()); |
-} |
- |
-// This tests that when setting a new description, the old default tracks are |
-// not destroyed and recreated. |
-// See: https://bugs.chromium.org/p/webrtc/issues/detail?id=5250 |
-TEST_F(PeerConnectionInterfaceTest, |
- DefaultTracksNotDestroyedAndRecreated) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- CreateAndSetRemoteOffer(kSdpStringWithoutStreamsAudioOnly); |
- |
- ASSERT_EQ(1u, observer_.remote_streams()->count()); |
- MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0); |
- ASSERT_EQ(1u, remote_stream->GetAudioTracks().size()); |
- |
- // Set the track to "disabled", then set a new description and ensure the |
- // track is still disabled, which ensures it hasn't been recreated. |
- remote_stream->GetAudioTracks()[0]->set_enabled(false); |
- CreateAndSetRemoteOffer(kSdpStringWithoutStreamsAudioOnly); |
- ASSERT_EQ(1u, remote_stream->GetAudioTracks().size()); |
- EXPECT_FALSE(remote_stream->GetAudioTracks()[0]->enabled()); |
-} |
- |
-// This tests that a default MediaStream is not created if a remote session |
-// description is updated to not have any MediaStreams. |
-TEST_F(PeerConnectionInterfaceTest, VerifyDefaultStreamIsNotCreated) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- CreateAndSetRemoteOffer(kSdpStringWithStream1); |
- rtc::scoped_refptr<StreamCollection> reference(CreateStreamCollection(1, 1)); |
- EXPECT_TRUE( |
- CompareStreamCollections(observer_.remote_streams(), reference.get())); |
- |
- CreateAndSetRemoteOffer(kSdpStringWithoutStreams); |
- EXPECT_EQ(0u, observer_.remote_streams()->count()); |
-} |
- |
-// This tests that an RtpSender is created when the local description is set |
-// after adding a local stream. |
-// TODO(deadbeef): This test and the one below it need to be updated when |
-// an RtpSender's lifetime isn't determined by when a local description is set. |
-TEST_F(PeerConnectionInterfaceTest, LocalDescriptionChanged) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- |
- // Create an offer with 1 stream with 2 tracks of each type. |
- rtc::scoped_refptr<StreamCollection> stream_collection = |
- CreateStreamCollection(1, 2); |
- pc_->AddStream(stream_collection->at(0)); |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- EXPECT_TRUE(DoSetLocalDescription(offer.release())); |
- |
- auto senders = pc_->GetSenders(); |
- EXPECT_EQ(4u, senders.size()); |
- EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0])); |
- EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0])); |
- EXPECT_TRUE(ContainsSender(senders, kAudioTracks[1])); |
- EXPECT_TRUE(ContainsSender(senders, kVideoTracks[1])); |
- |
- // Remove an audio and video track. |
- pc_->RemoveStream(stream_collection->at(0)); |
- stream_collection = CreateStreamCollection(1, 1); |
- pc_->AddStream(stream_collection->at(0)); |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- EXPECT_TRUE(DoSetLocalDescription(offer.release())); |
- |
- senders = pc_->GetSenders(); |
- EXPECT_EQ(2u, senders.size()); |
- EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0])); |
- EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0])); |
- EXPECT_FALSE(ContainsSender(senders, kAudioTracks[1])); |
- EXPECT_FALSE(ContainsSender(senders, kVideoTracks[1])); |
-} |
- |
-// This tests that an RtpSender is created when the local description is set |
-// before adding a local stream. |
-TEST_F(PeerConnectionInterfaceTest, |
- AddLocalStreamAfterLocalDescriptionChanged) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- |
- rtc::scoped_refptr<StreamCollection> stream_collection = |
- CreateStreamCollection(1, 2); |
- // Add a stream to create the offer, but remove it afterwards. |
- pc_->AddStream(stream_collection->at(0)); |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- pc_->RemoveStream(stream_collection->at(0)); |
- |
- EXPECT_TRUE(DoSetLocalDescription(offer.release())); |
- auto senders = pc_->GetSenders(); |
- EXPECT_EQ(0u, senders.size()); |
- |
- pc_->AddStream(stream_collection->at(0)); |
- senders = pc_->GetSenders(); |
- EXPECT_EQ(4u, senders.size()); |
- EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0])); |
- EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0])); |
- EXPECT_TRUE(ContainsSender(senders, kAudioTracks[1])); |
- EXPECT_TRUE(ContainsSender(senders, kVideoTracks[1])); |
-} |
- |
-// This tests that the expected behavior occurs if the SSRC on a local track is |
-// changed when SetLocalDescription is called. |
-TEST_F(PeerConnectionInterfaceTest, |
- ChangeSsrcOnTrackInLocalSessionDescription) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- |
- rtc::scoped_refptr<StreamCollection> stream_collection = |
- CreateStreamCollection(2, 1); |
- pc_->AddStream(stream_collection->at(0)); |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- // Grab a copy of the offer before it gets passed into the PC. |
- std::unique_ptr<JsepSessionDescription> modified_offer( |
- new JsepSessionDescription(JsepSessionDescription::kOffer)); |
- modified_offer->Initialize(offer->description()->Copy(), offer->session_id(), |
- offer->session_version()); |
- EXPECT_TRUE(DoSetLocalDescription(offer.release())); |
- |
- auto senders = pc_->GetSenders(); |
- EXPECT_EQ(2u, senders.size()); |
- EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0])); |
- EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0])); |
- |
- // Change the ssrc of the audio and video track. |
- cricket::MediaContentDescription* desc = |
- cricket::GetFirstAudioContentDescription(modified_offer->description()); |
- ASSERT_TRUE(desc != NULL); |
- for (StreamParams& stream : desc->mutable_streams()) { |
- for (unsigned int& ssrc : stream.ssrcs) { |
- ++ssrc; |
- } |
- } |
- |
- desc = |
- cricket::GetFirstVideoContentDescription(modified_offer->description()); |
- ASSERT_TRUE(desc != NULL); |
- for (StreamParams& stream : desc->mutable_streams()) { |
- for (unsigned int& ssrc : stream.ssrcs) { |
- ++ssrc; |
- } |
- } |
- |
- EXPECT_TRUE(DoSetLocalDescription(modified_offer.release())); |
- senders = pc_->GetSenders(); |
- EXPECT_EQ(2u, senders.size()); |
- EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0])); |
- EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0])); |
- // TODO(deadbeef): Once RtpSenders expose parameters, check that the SSRC |
- // changed. |
-} |
- |
-// This tests that the expected behavior occurs if a new session description is |
-// set with the same tracks, but on a different MediaStream. |
-TEST_F(PeerConnectionInterfaceTest, |
- SignalSameTracksInSeparateMediaStream) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- |
- rtc::scoped_refptr<StreamCollection> stream_collection = |
- CreateStreamCollection(2, 1); |
- pc_->AddStream(stream_collection->at(0)); |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- EXPECT_TRUE(DoSetLocalDescription(offer.release())); |
- |
- auto senders = pc_->GetSenders(); |
- EXPECT_EQ(2u, senders.size()); |
- EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0], kStreams[0])); |
- EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0], kStreams[0])); |
- |
- // Add a new MediaStream but with the same tracks as in the first stream. |
- rtc::scoped_refptr<webrtc::MediaStreamInterface> stream_1( |
- webrtc::MediaStream::Create(kStreams[1])); |
- stream_1->AddTrack(stream_collection->at(0)->GetVideoTracks()[0]); |
- stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0]); |
- pc_->AddStream(stream_1); |
- |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- EXPECT_TRUE(DoSetLocalDescription(offer.release())); |
- |
- auto new_senders = pc_->GetSenders(); |
- // Should be the same senders as before, but with updated stream id. |
- // Note that this behavior is subject to change in the future. |
- // We may decide the PC should ignore existing tracks in AddStream. |
- EXPECT_EQ(senders, new_senders); |
- EXPECT_TRUE(ContainsSender(new_senders, kAudioTracks[0], kStreams[1])); |
- EXPECT_TRUE(ContainsSender(new_senders, kVideoTracks[0], kStreams[1])); |
-} |
- |
-// This tests that PeerConnectionObserver::OnAddTrack is correctly called. |
-TEST_F(PeerConnectionInterfaceTest, OnAddTrackCallback) { |
- FakeConstraints constraints; |
- constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, |
- true); |
- CreatePeerConnection(&constraints); |
- CreateAndSetRemoteOffer(kSdpStringWithStream1AudioTrackOnly); |
- EXPECT_EQ(observer_.num_added_tracks_, 1); |
- EXPECT_EQ(observer_.last_added_track_label_, kAudioTracks[0]); |
- |
- // Create and set the updated remote SDP. |
- CreateAndSetRemoteOffer(kSdpStringWithStream1); |
- EXPECT_EQ(observer_.num_added_tracks_, 2); |
- EXPECT_EQ(observer_.last_added_track_label_, kVideoTracks[0]); |
-} |
- |
-// Test that when SetConfiguration is called and the configuration is |
-// changing, the next offer causes an ICE restart. |
-TEST_F(PeerConnectionInterfaceTest, SetConfigurationCausingIceRetart) { |
- PeerConnectionInterface::RTCConfiguration config; |
- config.type = PeerConnectionInterface::kRelay; |
- // Need to pass default constraints to prevent disabling of DTLS... |
- FakeConstraints default_constraints; |
- CreatePeerConnection(config, &default_constraints); |
- AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label"); |
- |
- // Do initial offer/answer so there's something to restart. |
- CreateOfferAsLocalDescription(); |
- CreateAnswerAsRemoteDescription(kSdpStringWithStream1); |
- |
- // Grab the ufrags. |
- std::vector<std::string> initial_ufrags = GetUfrags(pc_->local_description()); |
- |
- // Change ICE policy, which should trigger an ICE restart on the next offer. |
- config.type = PeerConnectionInterface::kAll; |
- EXPECT_TRUE(pc_->SetConfiguration(config)); |
- CreateOfferAsLocalDescription(); |
- |
- // Grab the new ufrags. |
- std::vector<std::string> subsequent_ufrags = |
- GetUfrags(pc_->local_description()); |
- |
- // Sanity check. |
- EXPECT_EQ(initial_ufrags.size(), subsequent_ufrags.size()); |
- // Check that each ufrag is different. |
- for (int i = 0; i < static_cast<int>(initial_ufrags.size()); ++i) { |
- EXPECT_NE(initial_ufrags[i], subsequent_ufrags[i]); |
- } |
-} |
- |
-// Test that when SetConfiguration is called and the configuration *isn't* |
-// changing, the next offer does *not* cause an ICE restart. |
-TEST_F(PeerConnectionInterfaceTest, SetConfigurationNotCausingIceRetart) { |
- PeerConnectionInterface::RTCConfiguration config; |
- config.type = PeerConnectionInterface::kRelay; |
- // Need to pass default constraints to prevent disabling of DTLS... |
- FakeConstraints default_constraints; |
- CreatePeerConnection(config, &default_constraints); |
- AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label"); |
- |
- // Do initial offer/answer so there's something to restart. |
- CreateOfferAsLocalDescription(); |
- CreateAnswerAsRemoteDescription(kSdpStringWithStream1); |
- |
- // Grab the ufrags. |
- std::vector<std::string> initial_ufrags = GetUfrags(pc_->local_description()); |
- |
- // Call SetConfiguration with a config identical to what the PC was |
- // constructed with. |
- EXPECT_TRUE(pc_->SetConfiguration(config)); |
- CreateOfferAsLocalDescription(); |
- |
- // Grab the new ufrags. |
- std::vector<std::string> subsequent_ufrags = |
- GetUfrags(pc_->local_description()); |
- |
- EXPECT_EQ(initial_ufrags, subsequent_ufrags); |
-} |
- |
-// Test for a weird corner case scenario: |
-// 1. Audio/video session established. |
-// 2. SetConfiguration changes ICE config; ICE restart needed. |
-// 3. ICE restart initiated by remote peer, but only for one m= section. |
-// 4. Next createOffer should initiate an ICE restart, but only for the other |
-// m= section; it would be pointless to do an ICE restart for the m= section |
-// that was already restarted. |
-TEST_F(PeerConnectionInterfaceTest, SetConfigurationCausingPartialIceRestart) { |
- PeerConnectionInterface::RTCConfiguration config; |
- config.type = PeerConnectionInterface::kRelay; |
- // Need to pass default constraints to prevent disabling of DTLS... |
- FakeConstraints default_constraints; |
- CreatePeerConnection(config, &default_constraints); |
- AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label"); |
- |
- // Do initial offer/answer so there's something to restart. |
- CreateOfferAsLocalDescription(); |
- CreateAnswerAsRemoteDescription(kSdpStringWithStream1); |
- |
- // Change ICE policy, which should set the "needs-ice-restart" flag. |
- config.type = PeerConnectionInterface::kAll; |
- EXPECT_TRUE(pc_->SetConfiguration(config)); |
- |
- // Do ICE restart for the first m= section, initiated by remote peer. |
- webrtc::JsepSessionDescription* remote_offer = |
- new webrtc::JsepSessionDescription(SessionDescriptionInterface::kOffer); |
- EXPECT_TRUE(remote_offer->Initialize(kSdpStringWithStream1, nullptr)); |
- remote_offer->description()->transport_infos()[0].description.ice_ufrag = |
- "modified"; |
- EXPECT_TRUE(DoSetRemoteDescription(remote_offer)); |
- CreateAnswerAsLocalDescription(); |
- |
- // Grab the ufrags. |
- std::vector<std::string> initial_ufrags = GetUfrags(pc_->local_description()); |
- ASSERT_EQ(2, initial_ufrags.size()); |
- |
- // Create offer and grab the new ufrags. |
- CreateOfferAsLocalDescription(); |
- std::vector<std::string> subsequent_ufrags = |
- GetUfrags(pc_->local_description()); |
- ASSERT_EQ(2, subsequent_ufrags.size()); |
- |
- // Ensure that only the ufrag for the second m= section changed. |
- EXPECT_EQ(initial_ufrags[0], subsequent_ufrags[0]); |
- EXPECT_NE(initial_ufrags[1], subsequent_ufrags[1]); |
-} |
- |
-// Tests that the methods to return current/pending descriptions work as |
-// expected at different points in the offer/answer exchange. This test does |
-// one offer/answer exchange as the offerer, then another as the answerer. |
-TEST_F(PeerConnectionInterfaceTest, CurrentAndPendingDescriptions) { |
- // This disables DTLS so we can apply an answer to ourselves. |
- CreatePeerConnection(); |
- |
- // Create initial local offer and get SDP (which will also be used as |
- // answer/pranswer); |
- std::unique_ptr<SessionDescriptionInterface> offer; |
- ASSERT_TRUE(DoCreateOffer(&offer, nullptr)); |
- std::string sdp; |
- EXPECT_TRUE(offer->ToString(&sdp)); |
- |
- // Set local offer. |
- SessionDescriptionInterface* local_offer = offer.release(); |
- EXPECT_TRUE(DoSetLocalDescription(local_offer)); |
- EXPECT_EQ(local_offer, pc_->pending_local_description()); |
- EXPECT_EQ(nullptr, pc_->pending_remote_description()); |
- EXPECT_EQ(nullptr, pc_->current_local_description()); |
- EXPECT_EQ(nullptr, pc_->current_remote_description()); |
- |
- // Set remote pranswer. |
- SessionDescriptionInterface* remote_pranswer = |
- webrtc::CreateSessionDescription(SessionDescriptionInterface::kPrAnswer, |
- sdp, nullptr); |
- EXPECT_TRUE(DoSetRemoteDescription(remote_pranswer)); |
- EXPECT_EQ(local_offer, pc_->pending_local_description()); |
- EXPECT_EQ(remote_pranswer, pc_->pending_remote_description()); |
- EXPECT_EQ(nullptr, pc_->current_local_description()); |
- EXPECT_EQ(nullptr, pc_->current_remote_description()); |
- |
- // Set remote answer. |
- SessionDescriptionInterface* remote_answer = webrtc::CreateSessionDescription( |
- SessionDescriptionInterface::kAnswer, sdp, nullptr); |
- EXPECT_TRUE(DoSetRemoteDescription(remote_answer)); |
- EXPECT_EQ(nullptr, pc_->pending_local_description()); |
- EXPECT_EQ(nullptr, pc_->pending_remote_description()); |
- EXPECT_EQ(local_offer, pc_->current_local_description()); |
- EXPECT_EQ(remote_answer, pc_->current_remote_description()); |
- |
- // Set remote offer. |
- SessionDescriptionInterface* remote_offer = webrtc::CreateSessionDescription( |
- SessionDescriptionInterface::kOffer, sdp, nullptr); |
- EXPECT_TRUE(DoSetRemoteDescription(remote_offer)); |
- EXPECT_EQ(remote_offer, pc_->pending_remote_description()); |
- EXPECT_EQ(nullptr, pc_->pending_local_description()); |
- EXPECT_EQ(local_offer, pc_->current_local_description()); |
- EXPECT_EQ(remote_answer, pc_->current_remote_description()); |
- |
- // Set local pranswer. |
- SessionDescriptionInterface* local_pranswer = |
- webrtc::CreateSessionDescription(SessionDescriptionInterface::kPrAnswer, |
- sdp, nullptr); |
- EXPECT_TRUE(DoSetLocalDescription(local_pranswer)); |
- EXPECT_EQ(remote_offer, pc_->pending_remote_description()); |
- EXPECT_EQ(local_pranswer, pc_->pending_local_description()); |
- EXPECT_EQ(local_offer, pc_->current_local_description()); |
- EXPECT_EQ(remote_answer, pc_->current_remote_description()); |
- |
- // Set local answer. |
- SessionDescriptionInterface* local_answer = webrtc::CreateSessionDescription( |
- SessionDescriptionInterface::kAnswer, sdp, nullptr); |
- EXPECT_TRUE(DoSetLocalDescription(local_answer)); |
- EXPECT_EQ(nullptr, pc_->pending_remote_description()); |
- EXPECT_EQ(nullptr, pc_->pending_local_description()); |
- EXPECT_EQ(remote_offer, pc_->current_remote_description()); |
- EXPECT_EQ(local_answer, pc_->current_local_description()); |
-} |
- |
-class PeerConnectionMediaConfigTest : public testing::Test { |
- protected: |
- void SetUp() override { |
- pcf_ = new rtc::RefCountedObject<PeerConnectionFactoryForTest>(); |
- pcf_->Initialize(); |
- } |
- const cricket::MediaConfig& TestCreatePeerConnection( |
- const PeerConnectionInterface::RTCConfiguration& config, |
- const MediaConstraintsInterface *constraints) { |
- pcf_->create_media_controller_called_ = false; |
- |
- rtc::scoped_refptr<PeerConnectionInterface> pc(pcf_->CreatePeerConnection( |
- config, constraints, nullptr, nullptr, &observer_)); |
- EXPECT_TRUE(pc.get()); |
- EXPECT_TRUE(pcf_->create_media_controller_called_); |
- return pcf_->create_media_controller_config_; |
- } |
- |
- rtc::scoped_refptr<PeerConnectionFactoryForTest> pcf_; |
- MockPeerConnectionObserver observer_; |
-}; |
- |
-// This test verifies the default behaviour with no constraints and a |
-// default RTCConfiguration. |
-TEST_F(PeerConnectionMediaConfigTest, TestDefaults) { |
- PeerConnectionInterface::RTCConfiguration config; |
- FakeConstraints constraints; |
- |
- const cricket::MediaConfig& media_config = |
- TestCreatePeerConnection(config, &constraints); |
- |
- EXPECT_FALSE(media_config.enable_dscp); |
- EXPECT_TRUE(media_config.video.enable_cpu_overuse_detection); |
- EXPECT_FALSE(media_config.video.disable_prerenderer_smoothing); |
- EXPECT_FALSE(media_config.video.suspend_below_min_bitrate); |
-} |
- |
-// This test verifies the DSCP constraint is recognized and passed to |
-// the CreateMediaController call. |
-TEST_F(PeerConnectionMediaConfigTest, TestDscpConstraintTrue) { |
- PeerConnectionInterface::RTCConfiguration config; |
- FakeConstraints constraints; |
- |
- constraints.AddOptional(webrtc::MediaConstraintsInterface::kEnableDscp, true); |
- const cricket::MediaConfig& media_config = |
- TestCreatePeerConnection(config, &constraints); |
- |
- EXPECT_TRUE(media_config.enable_dscp); |
-} |
- |
-// This test verifies the cpu overuse detection constraint is |
-// recognized and passed to the CreateMediaController call. |
-TEST_F(PeerConnectionMediaConfigTest, TestCpuOveruseConstraintFalse) { |
- PeerConnectionInterface::RTCConfiguration config; |
- FakeConstraints constraints; |
- |
- constraints.AddOptional( |
- webrtc::MediaConstraintsInterface::kCpuOveruseDetection, false); |
- const cricket::MediaConfig media_config = |
- TestCreatePeerConnection(config, &constraints); |
- |
- EXPECT_FALSE(media_config.video.enable_cpu_overuse_detection); |
-} |
- |
-// This test verifies that the disable_prerenderer_smoothing flag is |
-// propagated from RTCConfiguration to the CreateMediaController call. |
-TEST_F(PeerConnectionMediaConfigTest, TestDisablePrerendererSmoothingTrue) { |
- PeerConnectionInterface::RTCConfiguration config; |
- FakeConstraints constraints; |
- |
- config.set_prerenderer_smoothing(false); |
- const cricket::MediaConfig& media_config = |
- TestCreatePeerConnection(config, &constraints); |
- |
- EXPECT_TRUE(media_config.video.disable_prerenderer_smoothing); |
-} |
- |
-// This test verifies the suspend below min bitrate constraint is |
-// recognized and passed to the CreateMediaController call. |
-TEST_F(PeerConnectionMediaConfigTest, |
- TestSuspendBelowMinBitrateConstraintTrue) { |
- PeerConnectionInterface::RTCConfiguration config; |
- FakeConstraints constraints; |
- |
- constraints.AddOptional( |
- webrtc::MediaConstraintsInterface::kEnableVideoSuspendBelowMinBitrate, |
- true); |
- const cricket::MediaConfig media_config = |
- TestCreatePeerConnection(config, &constraints); |
- |
- EXPECT_TRUE(media_config.video.suspend_below_min_bitrate); |
-} |
- |
-// The following tests verify that session options are created correctly. |
-// TODO(deadbeef): Convert these tests to be more end-to-end. Instead of |
-// "verify options are converted correctly", should be "pass options into |
-// CreateOffer and verify the correct offer is produced." |
- |
-TEST(CreateSessionOptionsTest, GetOptionsForOfferWithInvalidAudioOption) { |
- RTCOfferAnswerOptions rtc_options; |
- rtc_options.offer_to_receive_audio = RTCOfferAnswerOptions::kUndefined - 1; |
- |
- cricket::MediaSessionOptions options; |
- EXPECT_FALSE(ExtractMediaSessionOptions(rtc_options, true, &options)); |
- |
- rtc_options.offer_to_receive_audio = |
- RTCOfferAnswerOptions::kMaxOfferToReceiveMedia + 1; |
- EXPECT_FALSE(ExtractMediaSessionOptions(rtc_options, true, &options)); |
-} |
- |
-TEST(CreateSessionOptionsTest, GetOptionsForOfferWithInvalidVideoOption) { |
- RTCOfferAnswerOptions rtc_options; |
- rtc_options.offer_to_receive_video = RTCOfferAnswerOptions::kUndefined - 1; |
- |
- cricket::MediaSessionOptions options; |
- EXPECT_FALSE(ExtractMediaSessionOptions(rtc_options, true, &options)); |
- |
- rtc_options.offer_to_receive_video = |
- RTCOfferAnswerOptions::kMaxOfferToReceiveMedia + 1; |
- EXPECT_FALSE(ExtractMediaSessionOptions(rtc_options, true, &options)); |
-} |
- |
-// Test that a MediaSessionOptions is created for an offer if |
-// OfferToReceiveAudio and OfferToReceiveVideo options are set. |
-TEST(CreateSessionOptionsTest, GetMediaSessionOptionsForOfferWithAudioVideo) { |
- RTCOfferAnswerOptions rtc_options; |
- rtc_options.offer_to_receive_audio = 1; |
- rtc_options.offer_to_receive_video = 1; |
- |
- cricket::MediaSessionOptions options; |
- EXPECT_TRUE(ExtractMediaSessionOptions(rtc_options, true, &options)); |
- EXPECT_TRUE(options.has_audio()); |
- EXPECT_TRUE(options.has_video()); |
- EXPECT_TRUE(options.bundle_enabled); |
-} |
- |
-// Test that a correct MediaSessionOptions is created for an offer if |
-// OfferToReceiveAudio is set. |
-TEST(CreateSessionOptionsTest, GetMediaSessionOptionsForOfferWithAudio) { |
- RTCOfferAnswerOptions rtc_options; |
- rtc_options.offer_to_receive_audio = 1; |
- |
- cricket::MediaSessionOptions options; |
- EXPECT_TRUE(ExtractMediaSessionOptions(rtc_options, true, &options)); |
- EXPECT_TRUE(options.has_audio()); |
- EXPECT_FALSE(options.has_video()); |
- EXPECT_TRUE(options.bundle_enabled); |
-} |
- |
-// Test that a correct MediaSessionOptions is created for an offer if |
-// the default OfferOptions are used. |
-TEST(CreateSessionOptionsTest, GetDefaultMediaSessionOptionsForOffer) { |
- RTCOfferAnswerOptions rtc_options; |
- |
- cricket::MediaSessionOptions options; |
- options.transport_options["audio"] = cricket::TransportOptions(); |
- options.transport_options["video"] = cricket::TransportOptions(); |
- EXPECT_TRUE(ExtractMediaSessionOptions(rtc_options, true, &options)); |
- EXPECT_TRUE(options.has_audio()); |
- EXPECT_FALSE(options.has_video()); |
- EXPECT_TRUE(options.bundle_enabled); |
- EXPECT_TRUE(options.vad_enabled); |
- EXPECT_FALSE(options.transport_options["audio"].ice_restart); |
- EXPECT_FALSE(options.transport_options["video"].ice_restart); |
-} |
- |
-// Test that a correct MediaSessionOptions is created for an offer if |
-// OfferToReceiveVideo is set. |
-TEST(CreateSessionOptionsTest, GetMediaSessionOptionsForOfferWithVideo) { |
- RTCOfferAnswerOptions rtc_options; |
- rtc_options.offer_to_receive_audio = 0; |
- rtc_options.offer_to_receive_video = 1; |
- |
- cricket::MediaSessionOptions options; |
- EXPECT_TRUE(ExtractMediaSessionOptions(rtc_options, true, &options)); |
- EXPECT_FALSE(options.has_audio()); |
- EXPECT_TRUE(options.has_video()); |
- EXPECT_TRUE(options.bundle_enabled); |
-} |
- |
-// Test that a correct MediaSessionOptions is created for an offer if |
-// UseRtpMux is set to false. |
-TEST(CreateSessionOptionsTest, |
- GetMediaSessionOptionsForOfferWithBundleDisabled) { |
- RTCOfferAnswerOptions rtc_options; |
- rtc_options.offer_to_receive_audio = 1; |
- rtc_options.offer_to_receive_video = 1; |
- rtc_options.use_rtp_mux = false; |
- |
- cricket::MediaSessionOptions options; |
- EXPECT_TRUE(ExtractMediaSessionOptions(rtc_options, true, &options)); |
- EXPECT_TRUE(options.has_audio()); |
- EXPECT_TRUE(options.has_video()); |
- EXPECT_FALSE(options.bundle_enabled); |
-} |
- |
-// Test that a correct MediaSessionOptions is created to restart ice if |
-// IceRestart is set. It also tests that subsequent MediaSessionOptions don't |
-// have |audio_transport_options.ice_restart| etc. set. |
-TEST(CreateSessionOptionsTest, GetMediaSessionOptionsForOfferWithIceRestart) { |
- RTCOfferAnswerOptions rtc_options; |
- rtc_options.ice_restart = true; |
- |
- cricket::MediaSessionOptions options; |
- options.transport_options["audio"] = cricket::TransportOptions(); |
- options.transport_options["video"] = cricket::TransportOptions(); |
- EXPECT_TRUE(ExtractMediaSessionOptions(rtc_options, true, &options)); |
- EXPECT_TRUE(options.transport_options["audio"].ice_restart); |
- EXPECT_TRUE(options.transport_options["video"].ice_restart); |
- |
- rtc_options = RTCOfferAnswerOptions(); |
- EXPECT_TRUE(ExtractMediaSessionOptions(rtc_options, true, &options)); |
- EXPECT_FALSE(options.transport_options["audio"].ice_restart); |
- EXPECT_FALSE(options.transport_options["video"].ice_restart); |
-} |
- |
-// Test that the MediaConstraints in an answer don't affect if audio and video |
-// is offered in an offer but that if kOfferToReceiveAudio or |
-// kOfferToReceiveVideo constraints are true in an offer, the media type will be |
-// included in subsequent answers. |
-TEST(CreateSessionOptionsTest, MediaConstraintsInAnswer) { |
- FakeConstraints answer_c; |
- answer_c.SetMandatoryReceiveAudio(true); |
- answer_c.SetMandatoryReceiveVideo(true); |
- |
- cricket::MediaSessionOptions answer_options; |
- EXPECT_TRUE(ParseConstraintsForAnswer(&answer_c, &answer_options)); |
- EXPECT_TRUE(answer_options.has_audio()); |
- EXPECT_TRUE(answer_options.has_video()); |
- |
- RTCOfferAnswerOptions rtc_offer_options; |
- |
- cricket::MediaSessionOptions offer_options; |
- EXPECT_TRUE( |
- ExtractMediaSessionOptions(rtc_offer_options, false, &offer_options)); |
- EXPECT_TRUE(offer_options.has_audio()); |
- EXPECT_TRUE(offer_options.has_video()); |
- |
- RTCOfferAnswerOptions updated_rtc_offer_options; |
- updated_rtc_offer_options.offer_to_receive_audio = 1; |
- updated_rtc_offer_options.offer_to_receive_video = 1; |
- |
- cricket::MediaSessionOptions updated_offer_options; |
- EXPECT_TRUE(ExtractMediaSessionOptions(updated_rtc_offer_options, false, |
- &updated_offer_options)); |
- EXPECT_TRUE(updated_offer_options.has_audio()); |
- EXPECT_TRUE(updated_offer_options.has_video()); |
- |
- // Since an offer has been created with both audio and video, subsequent |
- // offers and answers should contain both audio and video. |
- // Answers will only contain the media types that exist in the offer |
- // regardless of the value of |updated_answer_options.has_audio| and |
- // |updated_answer_options.has_video|. |
- FakeConstraints updated_answer_c; |
- answer_c.SetMandatoryReceiveAudio(false); |
- answer_c.SetMandatoryReceiveVideo(false); |
- |
- cricket::MediaSessionOptions updated_answer_options; |
- EXPECT_TRUE( |
- ParseConstraintsForAnswer(&updated_answer_c, &updated_answer_options)); |
- EXPECT_TRUE(updated_answer_options.has_audio()); |
- EXPECT_TRUE(updated_answer_options.has_video()); |
-} |
- |
-TEST(RTCErrorTypeTest, OstreamOperator) { |
- std::ostringstream oss; |
- oss << webrtc::RTCErrorType::NONE << ' ' |
- << webrtc::RTCErrorType::INVALID_PARAMETER << ' ' |
- << webrtc::RTCErrorType::INTERNAL_ERROR; |
- EXPECT_EQ("NONE INVALID_PARAMETER INTERNAL_ERROR", oss.str()); |
-} |
- |
-// Tests a few random fields being different. |
-TEST(RTCConfigurationTest, ComparisonOperators) { |
- PeerConnectionInterface::RTCConfiguration a; |
- PeerConnectionInterface::RTCConfiguration b; |
- EXPECT_EQ(a, b); |
- |
- PeerConnectionInterface::RTCConfiguration c; |
- c.servers.push_back(PeerConnectionInterface::IceServer()); |
- EXPECT_NE(a, c); |
- |
- PeerConnectionInterface::RTCConfiguration d; |
- d.type = PeerConnectionInterface::kRelay; |
- EXPECT_NE(a, d); |
- |
- PeerConnectionInterface::RTCConfiguration e; |
- e.audio_jitter_buffer_max_packets = 5; |
- EXPECT_NE(a, e); |
- |
- PeerConnectionInterface::RTCConfiguration f; |
- f.ice_connection_receiving_timeout = 1337; |
- EXPECT_NE(a, f); |
- |
- PeerConnectionInterface::RTCConfiguration g; |
- g.disable_ipv6 = true; |
- EXPECT_NE(a, g); |
- |
- PeerConnectionInterface::RTCConfiguration h( |
- PeerConnectionInterface::RTCConfigurationType::kAggressive); |
- EXPECT_NE(a, h); |
-} |