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