| 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 |
|---|
Chromium Code Reviews
Issue 2514883002:
Create //webrtc/api:libjingle_peerconnection_api + refactorings. (Closed)
