Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(98)

Side by Side Diff: webrtc/api/peerconnectionfactory_unittest.cc

Issue 2514883002: Create //webrtc/api:libjingle_peerconnection_api + refactorings. (Closed)
Patch Set: Rebase Created 3 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « webrtc/api/peerconnectionfactory.cc ('k') | webrtc/api/peerconnectioninterface.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(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 }
OLDNEW
« no previous file with comments | « webrtc/api/peerconnectionfactory.cc ('k') | webrtc/api/peerconnectioninterface.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698