OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
135 #endif | 135 #endif |
136 | 136 |
137 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory( | 137 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory( |
138 webrtc::CreatePeerConnectionFactory()); | 138 webrtc::CreatePeerConnectionFactory()); |
139 | 139 |
140 NullPeerConnectionObserver observer; | 140 NullPeerConnectionObserver observer; |
141 webrtc::PeerConnectionInterface::RTCConfiguration config; | 141 webrtc::PeerConnectionInterface::RTCConfiguration config; |
142 | 142 |
143 std::unique_ptr<FakeDtlsIdentityStore> dtls_identity_store( | 143 std::unique_ptr<FakeDtlsIdentityStore> dtls_identity_store( |
144 new FakeDtlsIdentityStore()); | 144 new FakeDtlsIdentityStore()); |
145 rtc::scoped_refptr<PeerConnectionInterface> pc(factory->CreatePeerConnection( | 145 rtc::scoped_refptr<PeerConnectionInterface> pc( |
146 config, nullptr, nullptr, std::move(dtls_identity_store), &observer)); | 146 factory->CreatePeerConnectionWithStore( |
| 147 config, nullptr, nullptr, std::move(dtls_identity_store), &observer)); |
147 | 148 |
148 EXPECT_TRUE(pc.get() != nullptr); | 149 EXPECT_TRUE(pc.get() != nullptr); |
149 } | 150 } |
150 | 151 |
151 // This test verifies creation of PeerConnection with valid STUN and TURN | 152 // This test verifies creation of PeerConnection with valid STUN and TURN |
152 // configuration. Also verifies the URL's parsed correctly as expected. | 153 // configuration. Also verifies the URL's parsed correctly as expected. |
153 TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServers) { | 154 TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServers) { |
154 PeerConnectionInterface::RTCConfiguration config; | 155 PeerConnectionInterface::RTCConfiguration config; |
155 webrtc::PeerConnectionInterface::IceServer ice_server; | 156 webrtc::PeerConnectionInterface::IceServer ice_server; |
156 ice_server.uri = kStunIceServer; | 157 ice_server.uri = kStunIceServer; |
157 config.servers.push_back(ice_server); | 158 config.servers.push_back(ice_server); |
158 ice_server.uri = kTurnIceServer; | 159 ice_server.uri = kTurnIceServer; |
159 ice_server.password = kTurnPassword; | 160 ice_server.password = kTurnPassword; |
160 config.servers.push_back(ice_server); | 161 config.servers.push_back(ice_server); |
161 ice_server.uri = kTurnIceServerWithTransport; | 162 ice_server.uri = kTurnIceServerWithTransport; |
162 ice_server.password = kTurnPassword; | 163 ice_server.password = kTurnPassword; |
163 config.servers.push_back(ice_server); | 164 config.servers.push_back(ice_server); |
164 std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store( | 165 std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store( |
165 new FakeDtlsIdentityStore()); | 166 new FakeDtlsIdentityStore()); |
166 rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection( | 167 rtc::scoped_refptr<PeerConnectionInterface> pc( |
167 config, nullptr, std::move(port_allocator_), | 168 factory_->CreatePeerConnectionWithStore( |
168 std::move(dtls_identity_store), &observer_)); | 169 config, nullptr, std::move(port_allocator_), |
| 170 std::move(dtls_identity_store), &observer_)); |
169 ASSERT_TRUE(pc.get() != NULL); | 171 ASSERT_TRUE(pc.get() != NULL); |
170 cricket::ServerAddresses stun_servers; | 172 cricket::ServerAddresses stun_servers; |
171 rtc::SocketAddress stun1("stun.l.google.com", 19302); | 173 rtc::SocketAddress stun1("stun.l.google.com", 19302); |
172 stun_servers.insert(stun1); | 174 stun_servers.insert(stun1); |
173 VerifyStunServers(stun_servers); | 175 VerifyStunServers(stun_servers); |
174 std::vector<cricket::RelayServerConfig> turn_servers; | 176 std::vector<cricket::RelayServerConfig> turn_servers; |
175 cricket::RelayServerConfig turn1("test.com", 1234, "test@hello.com", | 177 cricket::RelayServerConfig turn1("test.com", 1234, "test@hello.com", |
176 kTurnPassword, cricket::PROTO_UDP, false); | 178 kTurnPassword, cricket::PROTO_UDP, false); |
177 turn_servers.push_back(turn1); | 179 turn_servers.push_back(turn1); |
178 cricket::RelayServerConfig turn2("hello.com", kDefaultStunPort, "test", | 180 cricket::RelayServerConfig turn2("hello.com", kDefaultStunPort, "test", |
179 kTurnPassword, cricket::PROTO_TCP, false); | 181 kTurnPassword, cricket::PROTO_TCP, false); |
180 turn_servers.push_back(turn2); | 182 turn_servers.push_back(turn2); |
181 VerifyTurnServers(turn_servers); | 183 VerifyTurnServers(turn_servers); |
182 } | 184 } |
183 | 185 |
184 // This test verifies creation of PeerConnection with valid STUN and TURN | 186 // This test verifies creation of PeerConnection with valid STUN and TURN |
185 // configuration. Also verifies the list of URL's parsed correctly as expected. | 187 // configuration. Also verifies the list of URL's parsed correctly as expected. |
186 TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServersUrls) { | 188 TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServersUrls) { |
187 PeerConnectionInterface::RTCConfiguration config; | 189 PeerConnectionInterface::RTCConfiguration config; |
188 webrtc::PeerConnectionInterface::IceServer ice_server; | 190 webrtc::PeerConnectionInterface::IceServer ice_server; |
189 ice_server.urls.push_back(kStunIceServer); | 191 ice_server.urls.push_back(kStunIceServer); |
190 ice_server.urls.push_back(kTurnIceServer); | 192 ice_server.urls.push_back(kTurnIceServer); |
191 ice_server.urls.push_back(kTurnIceServerWithTransport); | 193 ice_server.urls.push_back(kTurnIceServerWithTransport); |
192 ice_server.password = kTurnPassword; | 194 ice_server.password = kTurnPassword; |
193 config.servers.push_back(ice_server); | 195 config.servers.push_back(ice_server); |
194 std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store( | 196 std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store( |
195 new FakeDtlsIdentityStore()); | 197 new FakeDtlsIdentityStore()); |
196 rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection( | 198 rtc::scoped_refptr<PeerConnectionInterface> pc( |
197 config, nullptr, std::move(port_allocator_), | 199 factory_->CreatePeerConnectionWithStore( |
198 std::move(dtls_identity_store), &observer_)); | 200 config, nullptr, std::move(port_allocator_), |
| 201 std::move(dtls_identity_store), &observer_)); |
199 ASSERT_TRUE(pc.get() != NULL); | 202 ASSERT_TRUE(pc.get() != NULL); |
200 cricket::ServerAddresses stun_servers; | 203 cricket::ServerAddresses stun_servers; |
201 rtc::SocketAddress stun1("stun.l.google.com", 19302); | 204 rtc::SocketAddress stun1("stun.l.google.com", 19302); |
202 stun_servers.insert(stun1); | 205 stun_servers.insert(stun1); |
203 VerifyStunServers(stun_servers); | 206 VerifyStunServers(stun_servers); |
204 std::vector<cricket::RelayServerConfig> turn_servers; | 207 std::vector<cricket::RelayServerConfig> turn_servers; |
205 cricket::RelayServerConfig turn1("test.com", 1234, "test@hello.com", | 208 cricket::RelayServerConfig turn1("test.com", 1234, "test@hello.com", |
206 kTurnPassword, cricket::PROTO_UDP, false); | 209 kTurnPassword, cricket::PROTO_UDP, false); |
207 turn_servers.push_back(turn1); | 210 turn_servers.push_back(turn1); |
208 cricket::RelayServerConfig turn2("hello.com", kDefaultStunPort, "test", | 211 cricket::RelayServerConfig turn2("hello.com", kDefaultStunPort, "test", |
209 kTurnPassword, cricket::PROTO_TCP, false); | 212 kTurnPassword, cricket::PROTO_TCP, false); |
210 turn_servers.push_back(turn2); | 213 turn_servers.push_back(turn2); |
211 VerifyTurnServers(turn_servers); | 214 VerifyTurnServers(turn_servers); |
212 } | 215 } |
213 | 216 |
214 TEST_F(PeerConnectionFactoryTest, CreatePCUsingNoUsernameInUri) { | 217 TEST_F(PeerConnectionFactoryTest, CreatePCUsingNoUsernameInUri) { |
215 PeerConnectionInterface::RTCConfiguration config; | 218 PeerConnectionInterface::RTCConfiguration config; |
216 webrtc::PeerConnectionInterface::IceServer ice_server; | 219 webrtc::PeerConnectionInterface::IceServer ice_server; |
217 ice_server.uri = kStunIceServer; | 220 ice_server.uri = kStunIceServer; |
218 config.servers.push_back(ice_server); | 221 config.servers.push_back(ice_server); |
219 ice_server.uri = kTurnIceServerWithNoUsernameInUri; | 222 ice_server.uri = kTurnIceServerWithNoUsernameInUri; |
220 ice_server.username = kTurnUsername; | 223 ice_server.username = kTurnUsername; |
221 ice_server.password = kTurnPassword; | 224 ice_server.password = kTurnPassword; |
222 config.servers.push_back(ice_server); | 225 config.servers.push_back(ice_server); |
223 std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store( | 226 std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store( |
224 new FakeDtlsIdentityStore()); | 227 new FakeDtlsIdentityStore()); |
225 rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection( | 228 rtc::scoped_refptr<PeerConnectionInterface> pc( |
226 config, nullptr, std::move(port_allocator_), | 229 factory_->CreatePeerConnectionWithStore( |
227 std::move(dtls_identity_store), &observer_)); | 230 config, nullptr, std::move(port_allocator_), |
| 231 std::move(dtls_identity_store), &observer_)); |
228 ASSERT_TRUE(pc.get() != NULL); | 232 ASSERT_TRUE(pc.get() != NULL); |
229 std::vector<cricket::RelayServerConfig> turn_servers; | 233 std::vector<cricket::RelayServerConfig> turn_servers; |
230 cricket::RelayServerConfig turn("test.com", 1234, kTurnUsername, | 234 cricket::RelayServerConfig turn("test.com", 1234, kTurnUsername, |
231 kTurnPassword, cricket::PROTO_UDP, false); | 235 kTurnPassword, cricket::PROTO_UDP, false); |
232 turn_servers.push_back(turn); | 236 turn_servers.push_back(turn); |
233 VerifyTurnServers(turn_servers); | 237 VerifyTurnServers(turn_servers); |
234 } | 238 } |
235 | 239 |
236 // This test verifies the PeerConnection created properly with TURN url which | 240 // This test verifies the PeerConnection created properly with TURN url which |
237 // has transport parameter in it. | 241 // has transport parameter in it. |
238 TEST_F(PeerConnectionFactoryTest, CreatePCUsingTurnUrlWithTransportParam) { | 242 TEST_F(PeerConnectionFactoryTest, CreatePCUsingTurnUrlWithTransportParam) { |
239 PeerConnectionInterface::RTCConfiguration config; | 243 PeerConnectionInterface::RTCConfiguration config; |
240 webrtc::PeerConnectionInterface::IceServer ice_server; | 244 webrtc::PeerConnectionInterface::IceServer ice_server; |
241 ice_server.uri = kTurnIceServerWithTransport; | 245 ice_server.uri = kTurnIceServerWithTransport; |
242 ice_server.password = kTurnPassword; | 246 ice_server.password = kTurnPassword; |
243 config.servers.push_back(ice_server); | 247 config.servers.push_back(ice_server); |
244 std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store( | 248 std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store( |
245 new FakeDtlsIdentityStore()); | 249 new FakeDtlsIdentityStore()); |
246 rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection( | 250 rtc::scoped_refptr<PeerConnectionInterface> pc( |
247 config, nullptr, std::move(port_allocator_), | 251 factory_->CreatePeerConnectionWithStore( |
248 std::move(dtls_identity_store), &observer_)); | 252 config, nullptr, std::move(port_allocator_), |
| 253 std::move(dtls_identity_store), &observer_)); |
249 ASSERT_TRUE(pc.get() != NULL); | 254 ASSERT_TRUE(pc.get() != NULL); |
250 std::vector<cricket::RelayServerConfig> turn_servers; | 255 std::vector<cricket::RelayServerConfig> turn_servers; |
251 cricket::RelayServerConfig turn("hello.com", kDefaultStunPort, "test", | 256 cricket::RelayServerConfig turn("hello.com", kDefaultStunPort, "test", |
252 kTurnPassword, cricket::PROTO_TCP, false); | 257 kTurnPassword, cricket::PROTO_TCP, false); |
253 turn_servers.push_back(turn); | 258 turn_servers.push_back(turn); |
254 VerifyTurnServers(turn_servers); | 259 VerifyTurnServers(turn_servers); |
255 } | 260 } |
256 | 261 |
257 TEST_F(PeerConnectionFactoryTest, CreatePCUsingSecureTurnUrl) { | 262 TEST_F(PeerConnectionFactoryTest, CreatePCUsingSecureTurnUrl) { |
258 PeerConnectionInterface::RTCConfiguration config; | 263 PeerConnectionInterface::RTCConfiguration config; |
259 webrtc::PeerConnectionInterface::IceServer ice_server; | 264 webrtc::PeerConnectionInterface::IceServer ice_server; |
260 ice_server.uri = kSecureTurnIceServer; | 265 ice_server.uri = kSecureTurnIceServer; |
261 ice_server.password = kTurnPassword; | 266 ice_server.password = kTurnPassword; |
262 config.servers.push_back(ice_server); | 267 config.servers.push_back(ice_server); |
263 ice_server.uri = kSecureTurnIceServerWithoutTransportParam; | 268 ice_server.uri = kSecureTurnIceServerWithoutTransportParam; |
264 ice_server.password = kTurnPassword; | 269 ice_server.password = kTurnPassword; |
265 config.servers.push_back(ice_server); | 270 config.servers.push_back(ice_server); |
266 ice_server.uri = kSecureTurnIceServerWithoutTransportAndPortParam; | 271 ice_server.uri = kSecureTurnIceServerWithoutTransportAndPortParam; |
267 ice_server.password = kTurnPassword; | 272 ice_server.password = kTurnPassword; |
268 config.servers.push_back(ice_server); | 273 config.servers.push_back(ice_server); |
269 std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store( | 274 std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store( |
270 new FakeDtlsIdentityStore()); | 275 new FakeDtlsIdentityStore()); |
271 rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection( | 276 rtc::scoped_refptr<PeerConnectionInterface> pc( |
272 config, nullptr, std::move(port_allocator_), | 277 factory_->CreatePeerConnectionWithStore( |
273 std::move(dtls_identity_store), &observer_)); | 278 config, nullptr, std::move(port_allocator_), |
| 279 std::move(dtls_identity_store), &observer_)); |
274 ASSERT_TRUE(pc.get() != NULL); | 280 ASSERT_TRUE(pc.get() != NULL); |
275 std::vector<cricket::RelayServerConfig> turn_servers; | 281 std::vector<cricket::RelayServerConfig> turn_servers; |
276 cricket::RelayServerConfig turn1("hello.com", kDefaultStunTlsPort, "test", | 282 cricket::RelayServerConfig turn1("hello.com", kDefaultStunTlsPort, "test", |
277 kTurnPassword, cricket::PROTO_TCP, true); | 283 kTurnPassword, cricket::PROTO_TCP, true); |
278 turn_servers.push_back(turn1); | 284 turn_servers.push_back(turn1); |
279 // TURNS with transport param should be default to tcp. | 285 // TURNS with transport param should be default to tcp. |
280 cricket::RelayServerConfig turn2("hello.com", 443, "test_no_transport", | 286 cricket::RelayServerConfig turn2("hello.com", 443, "test_no_transport", |
281 kTurnPassword, cricket::PROTO_TCP, true); | 287 kTurnPassword, cricket::PROTO_TCP, true); |
282 turn_servers.push_back(turn2); | 288 turn_servers.push_back(turn2); |
283 cricket::RelayServerConfig turn3("hello.com", kDefaultStunTlsPort, | 289 cricket::RelayServerConfig turn3("hello.com", kDefaultStunTlsPort, |
(...skipping 12 matching lines...) Expand all Loading... |
296 config.servers.push_back(ice_server); | 302 config.servers.push_back(ice_server); |
297 ice_server.uri = kStunIceServerWithIPv6Address; | 303 ice_server.uri = kStunIceServerWithIPv6Address; |
298 config.servers.push_back(ice_server); | 304 config.servers.push_back(ice_server); |
299 ice_server.uri = kStunIceServerWithIPv6AddressWithoutPort; | 305 ice_server.uri = kStunIceServerWithIPv6AddressWithoutPort; |
300 config.servers.push_back(ice_server); | 306 config.servers.push_back(ice_server); |
301 ice_server.uri = kTurnIceServerWithIPv6Address; | 307 ice_server.uri = kTurnIceServerWithIPv6Address; |
302 ice_server.password = kTurnPassword; | 308 ice_server.password = kTurnPassword; |
303 config.servers.push_back(ice_server); | 309 config.servers.push_back(ice_server); |
304 std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store( | 310 std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store( |
305 new FakeDtlsIdentityStore()); | 311 new FakeDtlsIdentityStore()); |
306 rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection( | 312 rtc::scoped_refptr<PeerConnectionInterface> pc( |
307 config, nullptr, std::move(port_allocator_), | 313 factory_->CreatePeerConnectionWithStore( |
308 std::move(dtls_identity_store), &observer_)); | 314 config, nullptr, std::move(port_allocator_), |
| 315 std::move(dtls_identity_store), &observer_)); |
309 ASSERT_TRUE(pc.get() != NULL); | 316 ASSERT_TRUE(pc.get() != NULL); |
310 cricket::ServerAddresses stun_servers; | 317 cricket::ServerAddresses stun_servers; |
311 rtc::SocketAddress stun1("1.2.3.4", 1234); | 318 rtc::SocketAddress stun1("1.2.3.4", 1234); |
312 stun_servers.insert(stun1); | 319 stun_servers.insert(stun1); |
313 rtc::SocketAddress stun2("1.2.3.4", 3478); | 320 rtc::SocketAddress stun2("1.2.3.4", 3478); |
314 stun_servers.insert(stun2); // Default port | 321 stun_servers.insert(stun2); // Default port |
315 rtc::SocketAddress stun3("2401:fa00:4::", 1234); | 322 rtc::SocketAddress stun3("2401:fa00:4::", 1234); |
316 stun_servers.insert(stun3); | 323 stun_servers.insert(stun3); |
317 rtc::SocketAddress stun4("2401:fa00:4::", 3478); | 324 rtc::SocketAddress stun4("2401:fa00:4::", 3478); |
318 stun_servers.insert(stun4); // Default port | 325 stun_servers.insert(stun4); // Default port |
(...skipping 27 matching lines...) Expand all Loading... |
346 track->set_enabled(false); | 353 track->set_enabled(false); |
347 EXPECT_TRUE(capturer->CaptureFrame()); | 354 EXPECT_TRUE(capturer->CaptureFrame()); |
348 EXPECT_EQ(2, local_renderer.num_rendered_frames()); | 355 EXPECT_EQ(2, local_renderer.num_rendered_frames()); |
349 EXPECT_TRUE(local_renderer.black_frame()); | 356 EXPECT_TRUE(local_renderer.black_frame()); |
350 | 357 |
351 track->set_enabled(true); | 358 track->set_enabled(true); |
352 EXPECT_TRUE(capturer->CaptureFrame()); | 359 EXPECT_TRUE(capturer->CaptureFrame()); |
353 EXPECT_EQ(3, local_renderer.num_rendered_frames()); | 360 EXPECT_EQ(3, local_renderer.num_rendered_frames()); |
354 EXPECT_FALSE(local_renderer.black_frame()); | 361 EXPECT_FALSE(local_renderer.black_frame()); |
355 } | 362 } |
OLD | NEW |