henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1 | /* |
kjellander | b24317b | 2016-02-10 15:54:43 | [diff] [blame] | 2 | * Copyright 2012 The WebRTC project authors. All Rights Reserved. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 3 | * |
kjellander | b24317b | 2016-02-10 15:54:43 | [diff] [blame] | 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 9 | */ |
| 10 | |
| 11 | #include <string> |
kwiberg | 0eb15ed | 2015-12-17 11:04:15 | [diff] [blame] | 12 | #include <utility> |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 13 | |
Henrik Kjellander | 15583c1 | 2016-02-10 09:53:12 | [diff] [blame] | 14 | #include "webrtc/api/mediastreaminterface.h" |
| 15 | #include "webrtc/api/peerconnectionfactory.h" |
phoglund | 37ebcf0 | 2016-01-08 13:04:57 | [diff] [blame] | 16 | #ifdef WEBRTC_ANDROID |
Henrik Kjellander | 15583c1 | 2016-02-10 09:53:12 | [diff] [blame] | 17 | #include "webrtc/api/test/androidtestinitializer.h" |
phoglund | 37ebcf0 | 2016-01-08 13:04:57 | [diff] [blame] | 18 | #endif |
Henrik Kjellander | 15583c1 | 2016-02-10 09:53:12 | [diff] [blame] | 19 | #include "webrtc/api/test/fakedtlsidentitystore.h" |
| 20 | #include "webrtc/api/test/fakevideotrackrenderer.h" |
| 21 | #include "webrtc/api/videosourceinterface.h" |
buildbot@webrtc.org | a09a999 | 2014-08-13 17:26:08 | [diff] [blame] | 22 | #include "webrtc/base/gunit.h" |
| 23 | #include "webrtc/base/scoped_ptr.h" |
| 24 | #include "webrtc/base/thread.h" |
kjellander | a96e2d7 | 2016-02-05 07:52:28 | [diff] [blame] | 25 | #include "webrtc/media/base/fakevideocapturer.h" |
kjellander@webrtc.org | 5ad1297 | 2016-02-12 05:39:40 | [diff] [blame] | 26 | #include "webrtc/media/engine/webrtccommon.h" |
| 27 | #include "webrtc/media/engine/webrtcvoe.h" |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 28 | #include "webrtc/p2p/client/fakeportallocator.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 29 | |
perkj@webrtc.org | c2dd5ee | 2014-11-04 11:31:29 | [diff] [blame] | 30 | using webrtc::DataChannelInterface; |
Henrik Boström | 5e56c59 | 2015-08-11 08:33:13 | [diff] [blame] | 31 | using webrtc::DtlsIdentityStoreInterface; |
| 32 | using webrtc::FakeVideoTrackRenderer; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 33 | using webrtc::MediaStreamInterface; |
| 34 | using webrtc::PeerConnectionFactoryInterface; |
| 35 | using webrtc::PeerConnectionInterface; |
| 36 | using webrtc::PeerConnectionObserver; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 37 | using webrtc::VideoSourceInterface; |
| 38 | using webrtc::VideoTrackInterface; |
| 39 | |
| 40 | namespace { |
| 41 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 42 | static const char kStunIceServer[] = "stun:stun.l.google.com:19302"; |
| 43 | static const char kTurnIceServer[] = "turn:test%40hello.com@test.com:1234"; |
| 44 | static const char kTurnIceServerWithTransport[] = |
| 45 | "turn:test@hello.com?transport=tcp"; |
| 46 | static const char kSecureTurnIceServer[] = |
| 47 | "turns:test@hello.com?transport=tcp"; |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 | [diff] [blame] | 48 | static const char kSecureTurnIceServerWithoutTransportParam[] = |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 49 | "turns:test_no_transport@hello.com:443"; |
| 50 | static const char kSecureTurnIceServerWithoutTransportAndPortParam[] = |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 | [diff] [blame] | 51 | "turns:test_no_transport@hello.com"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 52 | static const char kTurnIceServerWithNoUsernameInUri[] = |
| 53 | "turn:test.com:1234"; |
| 54 | static const char kTurnPassword[] = "turnpassword"; |
wu@webrtc.org | 91053e7 | 2013-08-10 07:18:04 | [diff] [blame] | 55 | static const int kDefaultStunPort = 3478; |
| 56 | static const int kDefaultStunTlsPort = 5349; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 57 | static const char kTurnUsername[] = "test"; |
sergeyu@chromium.org | a23f0ca | 2013-11-13 22:48:52 | [diff] [blame] | 58 | static const char kStunIceServerWithIPv4Address[] = "stun:1.2.3.4:1234"; |
| 59 | static const char kStunIceServerWithIPv4AddressWithoutPort[] = "stun:1.2.3.4"; |
| 60 | static const char kStunIceServerWithIPv6Address[] = "stun:[2401:fa00:4::]:1234"; |
| 61 | static const char kStunIceServerWithIPv6AddressWithoutPort[] = |
| 62 | "stun:[2401:fa00:4::]"; |
sergeyu@chromium.org | a23f0ca | 2013-11-13 22:48:52 | [diff] [blame] | 63 | static const char kTurnIceServerWithIPv6Address[] = |
| 64 | "turn:test@[2401:fa00:4::]:1234"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 65 | |
| 66 | class NullPeerConnectionObserver : public PeerConnectionObserver { |
| 67 | public: |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 68 | virtual void OnMessage(const std::string& msg) {} |
| 69 | virtual void OnSignalingMessage(const std::string& msg) {} |
| 70 | virtual void OnSignalingChange( |
| 71 | PeerConnectionInterface::SignalingState new_state) {} |
| 72 | virtual void OnAddStream(MediaStreamInterface* stream) {} |
| 73 | virtual void OnRemoveStream(MediaStreamInterface* stream) {} |
perkj@webrtc.org | c2dd5ee | 2014-11-04 11:31:29 | [diff] [blame] | 74 | virtual void OnDataChannel(DataChannelInterface* data_channel) {} |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 75 | virtual void OnRenegotiationNeeded() {} |
| 76 | virtual void OnIceConnectionChange( |
| 77 | PeerConnectionInterface::IceConnectionState new_state) {} |
| 78 | virtual void OnIceGatheringChange( |
| 79 | PeerConnectionInterface::IceGatheringState new_state) {} |
| 80 | virtual void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) {} |
| 81 | }; |
| 82 | |
| 83 | } // namespace |
| 84 | |
| 85 | class PeerConnectionFactoryTest : public testing::Test { |
| 86 | void SetUp() { |
phoglund | 37ebcf0 | 2016-01-08 13:04:57 | [diff] [blame] | 87 | #ifdef WEBRTC_ANDROID |
| 88 | webrtc::InitializeAndroidObjects(); |
| 89 | #endif |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 | [diff] [blame] | 90 | factory_ = webrtc::CreatePeerConnectionFactory(rtc::Thread::Current(), |
| 91 | rtc::Thread::Current(), |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 92 | NULL, |
| 93 | NULL, |
| 94 | NULL); |
| 95 | |
| 96 | ASSERT_TRUE(factory_.get() != NULL); |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 97 | port_allocator_.reset( |
| 98 | new cricket::FakePortAllocator(rtc::Thread::Current(), nullptr)); |
| 99 | raw_port_allocator_ = port_allocator_.get(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 100 | } |
| 101 | |
| 102 | protected: |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 103 | void VerifyStunServers(cricket::ServerAddresses stun_servers) { |
| 104 | EXPECT_EQ(stun_servers, raw_port_allocator_->stun_servers()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 105 | } |
| 106 | |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 107 | void VerifyTurnServers(std::vector<cricket::RelayServerConfig> turn_servers) { |
| 108 | EXPECT_EQ(turn_servers.size(), raw_port_allocator_->turn_servers().size()); |
| 109 | for (size_t i = 0; i < turn_servers.size(); ++i) { |
| 110 | ASSERT_EQ(1u, turn_servers[i].ports.size()); |
| 111 | EXPECT_EQ(1u, raw_port_allocator_->turn_servers()[i].ports.size()); |
| 112 | EXPECT_EQ( |
| 113 | turn_servers[i].ports[0].address.ToString(), |
| 114 | raw_port_allocator_->turn_servers()[i].ports[0].address.ToString()); |
| 115 | EXPECT_EQ(turn_servers[i].ports[0].proto, |
| 116 | raw_port_allocator_->turn_servers()[i].ports[0].proto); |
| 117 | EXPECT_EQ(turn_servers[i].credentials.username, |
| 118 | raw_port_allocator_->turn_servers()[i].credentials.username); |
| 119 | EXPECT_EQ(turn_servers[i].credentials.password, |
| 120 | raw_port_allocator_->turn_servers()[i].credentials.password); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 121 | } |
| 122 | } |
| 123 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 | [diff] [blame] | 124 | rtc::scoped_refptr<PeerConnectionFactoryInterface> factory_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 125 | NullPeerConnectionObserver observer_; |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 126 | rtc::scoped_ptr<cricket::FakePortAllocator> port_allocator_; |
| 127 | // Since the PC owns the port allocator after it's been initialized, |
| 128 | // this should only be used when known to be safe. |
| 129 | cricket::FakePortAllocator* raw_port_allocator_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 130 | }; |
| 131 | |
| 132 | // Verify creation of PeerConnection using internal ADM, video factory and |
| 133 | // internal libjingle threads. |
| 134 | TEST(PeerConnectionFactoryTestInternal, CreatePCUsingInternalModules) { |
phoglund | 37ebcf0 | 2016-01-08 13:04:57 | [diff] [blame] | 135 | #ifdef WEBRTC_ANDROID |
| 136 | webrtc::InitializeAndroidObjects(); |
| 137 | #endif |
| 138 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 | [diff] [blame] | 139 | rtc::scoped_refptr<PeerConnectionFactoryInterface> factory( |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 140 | webrtc::CreatePeerConnectionFactory()); |
| 141 | |
| 142 | NullPeerConnectionObserver observer; |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 143 | webrtc::PeerConnectionInterface::RTCConfiguration config; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 144 | |
Henrik Boström | 5e56c59 | 2015-08-11 08:33:13 | [diff] [blame] | 145 | rtc::scoped_ptr<FakeDtlsIdentityStore> dtls_identity_store( |
| 146 | new FakeDtlsIdentityStore()); |
kwiberg | 0eb15ed | 2015-12-17 11:04:15 | [diff] [blame] | 147 | rtc::scoped_refptr<PeerConnectionInterface> pc(factory->CreatePeerConnection( |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 148 | config, nullptr, nullptr, std::move(dtls_identity_store), &observer)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 149 | |
Henrik Boström | 5e56c59 | 2015-08-11 08:33:13 | [diff] [blame] | 150 | EXPECT_TRUE(pc.get() != nullptr); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 151 | } |
| 152 | |
| 153 | // This test verifies creation of PeerConnection with valid STUN and TURN |
| 154 | // configuration. Also verifies the URL's parsed correctly as expected. |
| 155 | TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServers) { |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 156 | PeerConnectionInterface::RTCConfiguration config; |
| 157 | webrtc::PeerConnectionInterface::IceServer ice_server; |
| 158 | ice_server.uri = kStunIceServer; |
| 159 | config.servers.push_back(ice_server); |
| 160 | ice_server.uri = kTurnIceServer; |
| 161 | ice_server.password = kTurnPassword; |
| 162 | config.servers.push_back(ice_server); |
| 163 | ice_server.uri = kTurnIceServerWithTransport; |
| 164 | ice_server.password = kTurnPassword; |
| 165 | config.servers.push_back(ice_server); |
Henrik Boström | 5e56c59 | 2015-08-11 08:33:13 | [diff] [blame] | 166 | rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store( |
| 167 | new FakeDtlsIdentityStore()); |
kwiberg | 0eb15ed | 2015-12-17 11:04:15 | [diff] [blame] | 168 | rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection( |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 169 | config, nullptr, std::move(port_allocator_), |
| 170 | std::move(dtls_identity_store), &observer_)); |
| 171 | ASSERT_TRUE(pc.get() != NULL); |
| 172 | cricket::ServerAddresses stun_servers; |
| 173 | rtc::SocketAddress stun1("stun.l.google.com", 19302); |
| 174 | stun_servers.insert(stun1); |
| 175 | VerifyStunServers(stun_servers); |
| 176 | std::vector<cricket::RelayServerConfig> turn_servers; |
| 177 | cricket::RelayServerConfig turn1("test.com", 1234, "test@hello.com", |
| 178 | kTurnPassword, cricket::PROTO_UDP, false); |
| 179 | turn_servers.push_back(turn1); |
| 180 | cricket::RelayServerConfig turn2("hello.com", kDefaultStunPort, "test", |
| 181 | kTurnPassword, cricket::PROTO_TCP, false); |
| 182 | turn_servers.push_back(turn2); |
| 183 | VerifyTurnServers(turn_servers); |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 184 | } |
| 185 | |
| 186 | // This test verifies creation of PeerConnection with valid STUN and TURN |
Joachim Bauch | 7c4e745 | 2015-05-28 21:06:30 | [diff] [blame] | 187 | // configuration. Also verifies the list of URL's parsed correctly as expected. |
| 188 | TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServersUrls) { |
| 189 | PeerConnectionInterface::RTCConfiguration config; |
| 190 | webrtc::PeerConnectionInterface::IceServer ice_server; |
| 191 | ice_server.urls.push_back(kStunIceServer); |
| 192 | ice_server.urls.push_back(kTurnIceServer); |
| 193 | ice_server.urls.push_back(kTurnIceServerWithTransport); |
| 194 | ice_server.password = kTurnPassword; |
| 195 | config.servers.push_back(ice_server); |
Henrik Boström | 5e56c59 | 2015-08-11 08:33:13 | [diff] [blame] | 196 | rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store( |
| 197 | new FakeDtlsIdentityStore()); |
kwiberg | 0eb15ed | 2015-12-17 11:04:15 | [diff] [blame] | 198 | rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection( |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 199 | config, nullptr, std::move(port_allocator_), |
kwiberg | 0eb15ed | 2015-12-17 11:04:15 | [diff] [blame] | 200 | std::move(dtls_identity_store), &observer_)); |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 201 | ASSERT_TRUE(pc.get() != NULL); |
| 202 | cricket::ServerAddresses stun_servers; |
| 203 | rtc::SocketAddress stun1("stun.l.google.com", 19302); |
| 204 | stun_servers.insert(stun1); |
| 205 | VerifyStunServers(stun_servers); |
| 206 | std::vector<cricket::RelayServerConfig> turn_servers; |
| 207 | cricket::RelayServerConfig turn1("test.com", 1234, "test@hello.com", |
| 208 | kTurnPassword, cricket::PROTO_UDP, false); |
| 209 | turn_servers.push_back(turn1); |
| 210 | cricket::RelayServerConfig turn2("hello.com", kDefaultStunPort, "test", |
| 211 | kTurnPassword, cricket::PROTO_TCP, false); |
| 212 | turn_servers.push_back(turn2); |
| 213 | VerifyTurnServers(turn_servers); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 214 | } |
| 215 | |
| 216 | TEST_F(PeerConnectionFactoryTest, CreatePCUsingNoUsernameInUri) { |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 217 | PeerConnectionInterface::RTCConfiguration config; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 218 | webrtc::PeerConnectionInterface::IceServer ice_server; |
| 219 | ice_server.uri = kStunIceServer; |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 220 | config.servers.push_back(ice_server); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 221 | ice_server.uri = kTurnIceServerWithNoUsernameInUri; |
| 222 | ice_server.username = kTurnUsername; |
| 223 | ice_server.password = kTurnPassword; |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 224 | config.servers.push_back(ice_server); |
Henrik Boström | 5e56c59 | 2015-08-11 08:33:13 | [diff] [blame] | 225 | rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store( |
| 226 | new FakeDtlsIdentityStore()); |
kwiberg | 0eb15ed | 2015-12-17 11:04:15 | [diff] [blame] | 227 | rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection( |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 228 | config, nullptr, std::move(port_allocator_), |
| 229 | std::move(dtls_identity_store), &observer_)); |
| 230 | ASSERT_TRUE(pc.get() != NULL); |
| 231 | std::vector<cricket::RelayServerConfig> turn_servers; |
| 232 | cricket::RelayServerConfig turn("test.com", 1234, kTurnUsername, |
| 233 | kTurnPassword, cricket::PROTO_UDP, false); |
| 234 | turn_servers.push_back(turn); |
| 235 | VerifyTurnServers(turn_servers); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 236 | } |
| 237 | |
| 238 | // This test verifies the PeerConnection created properly with TURN url which |
| 239 | // has transport parameter in it. |
| 240 | TEST_F(PeerConnectionFactoryTest, CreatePCUsingTurnUrlWithTransportParam) { |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 241 | PeerConnectionInterface::RTCConfiguration config; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 242 | webrtc::PeerConnectionInterface::IceServer ice_server; |
| 243 | ice_server.uri = kTurnIceServerWithTransport; |
| 244 | ice_server.password = kTurnPassword; |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 245 | config.servers.push_back(ice_server); |
Henrik Boström | 5e56c59 | 2015-08-11 08:33:13 | [diff] [blame] | 246 | rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store( |
| 247 | new FakeDtlsIdentityStore()); |
kwiberg | 0eb15ed | 2015-12-17 11:04:15 | [diff] [blame] | 248 | rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection( |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 249 | config, nullptr, std::move(port_allocator_), |
| 250 | std::move(dtls_identity_store), &observer_)); |
| 251 | ASSERT_TRUE(pc.get() != NULL); |
| 252 | std::vector<cricket::RelayServerConfig> turn_servers; |
| 253 | cricket::RelayServerConfig turn("hello.com", kDefaultStunPort, "test", |
| 254 | kTurnPassword, cricket::PROTO_TCP, false); |
| 255 | turn_servers.push_back(turn); |
| 256 | VerifyTurnServers(turn_servers); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 257 | } |
| 258 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 259 | TEST_F(PeerConnectionFactoryTest, CreatePCUsingSecureTurnUrl) { |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 260 | PeerConnectionInterface::RTCConfiguration config; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 261 | webrtc::PeerConnectionInterface::IceServer ice_server; |
| 262 | ice_server.uri = kSecureTurnIceServer; |
| 263 | ice_server.password = kTurnPassword; |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 264 | config.servers.push_back(ice_server); |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 | [diff] [blame] | 265 | ice_server.uri = kSecureTurnIceServerWithoutTransportParam; |
| 266 | ice_server.password = kTurnPassword; |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 267 | config.servers.push_back(ice_server); |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 268 | ice_server.uri = kSecureTurnIceServerWithoutTransportAndPortParam; |
| 269 | ice_server.password = kTurnPassword; |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 270 | config.servers.push_back(ice_server); |
Henrik Boström | 5e56c59 | 2015-08-11 08:33:13 | [diff] [blame] | 271 | rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store( |
| 272 | new FakeDtlsIdentityStore()); |
kwiberg | 0eb15ed | 2015-12-17 11:04:15 | [diff] [blame] | 273 | rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection( |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 274 | config, nullptr, std::move(port_allocator_), |
| 275 | std::move(dtls_identity_store), &observer_)); |
| 276 | ASSERT_TRUE(pc.get() != NULL); |
| 277 | std::vector<cricket::RelayServerConfig> turn_servers; |
| 278 | cricket::RelayServerConfig turn1("hello.com", kDefaultStunTlsPort, "test", |
| 279 | kTurnPassword, cricket::PROTO_TCP, true); |
| 280 | turn_servers.push_back(turn1); |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 | [diff] [blame] | 281 | // TURNS with transport param should be default to tcp. |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 282 | cricket::RelayServerConfig turn2("hello.com", 443, "test_no_transport", |
| 283 | kTurnPassword, cricket::PROTO_TCP, true); |
| 284 | turn_servers.push_back(turn2); |
| 285 | cricket::RelayServerConfig turn3("hello.com", kDefaultStunTlsPort, |
| 286 | "test_no_transport", kTurnPassword, |
| 287 | cricket::PROTO_TCP, true); |
| 288 | turn_servers.push_back(turn3); |
| 289 | VerifyTurnServers(turn_servers); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 290 | } |
| 291 | |
sergeyu@chromium.org | a23f0ca | 2013-11-13 22:48:52 | [diff] [blame] | 292 | TEST_F(PeerConnectionFactoryTest, CreatePCUsingIPLiteralAddress) { |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 293 | PeerConnectionInterface::RTCConfiguration config; |
sergeyu@chromium.org | a23f0ca | 2013-11-13 22:48:52 | [diff] [blame] | 294 | webrtc::PeerConnectionInterface::IceServer ice_server; |
| 295 | ice_server.uri = kStunIceServerWithIPv4Address; |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 296 | config.servers.push_back(ice_server); |
sergeyu@chromium.org | a23f0ca | 2013-11-13 22:48:52 | [diff] [blame] | 297 | ice_server.uri = kStunIceServerWithIPv4AddressWithoutPort; |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 298 | config.servers.push_back(ice_server); |
sergeyu@chromium.org | a23f0ca | 2013-11-13 22:48:52 | [diff] [blame] | 299 | ice_server.uri = kStunIceServerWithIPv6Address; |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 300 | config.servers.push_back(ice_server); |
sergeyu@chromium.org | a23f0ca | 2013-11-13 22:48:52 | [diff] [blame] | 301 | ice_server.uri = kStunIceServerWithIPv6AddressWithoutPort; |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 302 | config.servers.push_back(ice_server); |
sergeyu@chromium.org | a23f0ca | 2013-11-13 22:48:52 | [diff] [blame] | 303 | ice_server.uri = kTurnIceServerWithIPv6Address; |
| 304 | ice_server.password = kTurnPassword; |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 | [diff] [blame] | 305 | config.servers.push_back(ice_server); |
Henrik Boström | 5e56c59 | 2015-08-11 08:33:13 | [diff] [blame] | 306 | rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store( |
| 307 | new FakeDtlsIdentityStore()); |
kwiberg | 0eb15ed | 2015-12-17 11:04:15 | [diff] [blame] | 308 | rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection( |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 309 | config, nullptr, std::move(port_allocator_), |
| 310 | std::move(dtls_identity_store), &observer_)); |
| 311 | ASSERT_TRUE(pc.get() != NULL); |
| 312 | cricket::ServerAddresses stun_servers; |
| 313 | rtc::SocketAddress stun1("1.2.3.4", 1234); |
| 314 | stun_servers.insert(stun1); |
| 315 | rtc::SocketAddress stun2("1.2.3.4", 3478); |
| 316 | stun_servers.insert(stun2); // Default port |
| 317 | rtc::SocketAddress stun3("2401:fa00:4::", 1234); |
| 318 | stun_servers.insert(stun3); |
| 319 | rtc::SocketAddress stun4("2401:fa00:4::", 3478); |
| 320 | stun_servers.insert(stun4); // Default port |
| 321 | VerifyStunServers(stun_servers); |
buildbot@webrtc.org | f875f15 | 2014-04-14 16:06:21 | [diff] [blame] | 322 | |
Taylor Brandstetter | 0c7e9f5 | 2015-12-29 22:14:52 | [diff] [blame] | 323 | std::vector<cricket::RelayServerConfig> turn_servers; |
| 324 | cricket::RelayServerConfig turn1("2401:fa00:4::", 1234, "test", kTurnPassword, |
| 325 | cricket::PROTO_UDP, false); |
| 326 | turn_servers.push_back(turn1); |
| 327 | VerifyTurnServers(turn_servers); |
sergeyu@chromium.org | a23f0ca | 2013-11-13 22:48:52 | [diff] [blame] | 328 | } |
| 329 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 330 | // This test verifies the captured stream is rendered locally using a |
| 331 | // local video track. |
| 332 | TEST_F(PeerConnectionFactoryTest, LocalRendering) { |
| 333 | cricket::FakeVideoCapturer* capturer = new cricket::FakeVideoCapturer(); |
| 334 | // The source take ownership of |capturer|. |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 | [diff] [blame] | 335 | rtc::scoped_refptr<VideoSourceInterface> source( |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 336 | factory_->CreateVideoSource(capturer, NULL)); |
| 337 | ASSERT_TRUE(source.get() != NULL); |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 | [diff] [blame] | 338 | rtc::scoped_refptr<VideoTrackInterface> track( |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 339 | factory_->CreateVideoTrack("testlabel", source)); |
| 340 | ASSERT_TRUE(track.get() != NULL); |
| 341 | FakeVideoTrackRenderer local_renderer(track); |
| 342 | |
| 343 | EXPECT_EQ(0, local_renderer.num_rendered_frames()); |
| 344 | EXPECT_TRUE(capturer->CaptureFrame()); |
| 345 | EXPECT_EQ(1, local_renderer.num_rendered_frames()); |
nisse | 81354f5 | 2016-01-19 08:23:24 | [diff] [blame] | 346 | EXPECT_FALSE(local_renderer.black_frame()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 347 | |
| 348 | track->set_enabled(false); |
| 349 | EXPECT_TRUE(capturer->CaptureFrame()); |
nisse | 81354f5 | 2016-01-19 08:23:24 | [diff] [blame] | 350 | EXPECT_EQ(2, local_renderer.num_rendered_frames()); |
| 351 | EXPECT_TRUE(local_renderer.black_frame()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 352 | |
| 353 | track->set_enabled(true); |
| 354 | EXPECT_TRUE(capturer->CaptureFrame()); |
nisse | 81354f5 | 2016-01-19 08:23:24 | [diff] [blame] | 355 | EXPECT_EQ(3, local_renderer.num_rendered_frames()); |
| 356 | EXPECT_FALSE(local_renderer.black_frame()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 357 | } |