Move talk/app/webrtc to webrtc/api
The previously disabled warnings that were inherited from
talk/build/common.gypi are now replaced by target-specific disabling
of only the failing warnings. Additional disabling was needed since the stricter
compilation warnings that applies to code in webrtc/.
License headers will be updated in a follow-up CL.
Other modifications:
* Updated the header guards.
* Sorted the includes using chromium/src/tools/sort-headers.py
except for these files:
talk/app/webrtc/peerconnectionendtoend_unittest.cc
talk/app/webrtc/java/jni/androidmediadecoder_jni.cc
talk/app/webrtc/java/jni/androidmediaencoder_jni.cc
webrtc/media/devices/win32devicemanager.cc
The HAVE_SCTP define was added for the peerconnection_unittests target
in api_tests.gyp.
I also checked that none of
SRTP_RELATIVE_PATH
HAVE_SRTP
HAVE_WEBRTC_VIDEO
HAVE_WEBRTC_VOICE
were used by the talk/app/webrtc code.
For Chromium, the following changes will need to be applied to the roll CL that updates the
DEPS for WebRTC and libjingle:
https://codereview.chromium.org/1615433002
BUG=webrtc:5418
NOPRESUBMIT=True
R=deadbeef@webrtc.org, pthatcher@webrtc.org, tommi@webrtc.org
Review URL: https://codereview.webrtc.org/1610243002 .
Cr-Commit-Position: refs/heads/master@{#11545}
diff --git a/webrtc/api/peerconnectionfactory_unittest.cc b/webrtc/api/peerconnectionfactory_unittest.cc
new file mode 100644
index 0000000..a526ea5
--- /dev/null
+++ b/webrtc/api/peerconnectionfactory_unittest.cc
@@ -0,0 +1,374 @@
+/*
+ * libjingle
+ * Copyright 2012 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <string>
+#include <utility>
+
+#include "webrtc/api/mediastreaminterface.h"
+#include "webrtc/api/peerconnectionfactory.h"
+#ifdef WEBRTC_ANDROID
+#include "webrtc/api/test/androidtestinitializer.h"
+#endif
+#include "webrtc/api/test/fakedtlsidentitystore.h"
+#include "webrtc/api/test/fakevideotrackrenderer.h"
+#include "webrtc/api/videosourceinterface.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/media/base/fakevideocapturer.h"
+#include "webrtc/media/webrtc/webrtccommon.h"
+#include "webrtc/media/webrtc/webrtcvoe.h"
+#include "webrtc/p2p/client/fakeportallocator.h"
+
+using webrtc::DataChannelInterface;
+using webrtc::DtlsIdentityStoreInterface;
+using webrtc::FakeVideoTrackRenderer;
+using webrtc::MediaStreamInterface;
+using webrtc::PeerConnectionFactoryInterface;
+using webrtc::PeerConnectionInterface;
+using webrtc::PeerConnectionObserver;
+using webrtc::VideoSourceInterface;
+using webrtc::VideoTrackInterface;
+
+namespace {
+
+static const char kStunIceServer[] = "stun:stun.l.google.com:19302";
+static const char kTurnIceServer[] = "turn:test%40hello.com@test.com:1234";
+static const char kTurnIceServerWithTransport[] =
+ "turn:test@hello.com?transport=tcp";
+static const char kSecureTurnIceServer[] =
+ "turns:test@hello.com?transport=tcp";
+static const char kSecureTurnIceServerWithoutTransportParam[] =
+ "turns:test_no_transport@hello.com:443";
+static const char kSecureTurnIceServerWithoutTransportAndPortParam[] =
+ "turns:test_no_transport@hello.com";
+static const char kTurnIceServerWithNoUsernameInUri[] =
+ "turn:test.com:1234";
+static const char kTurnPassword[] = "turnpassword";
+static const int kDefaultStunPort = 3478;
+static const int kDefaultStunTlsPort = 5349;
+static const char kTurnUsername[] = "test";
+static const char kStunIceServerWithIPv4Address[] = "stun:1.2.3.4:1234";
+static const char kStunIceServerWithIPv4AddressWithoutPort[] = "stun:1.2.3.4";
+static const char kStunIceServerWithIPv6Address[] = "stun:[2401:fa00:4::]:1234";
+static const char kStunIceServerWithIPv6AddressWithoutPort[] =
+ "stun:[2401:fa00:4::]";
+static const char kTurnIceServerWithIPv6Address[] =
+ "turn:test@[2401:fa00:4::]:1234";
+
+class NullPeerConnectionObserver : public PeerConnectionObserver {
+ public:
+ virtual void OnMessage(const std::string& msg) {}
+ virtual void OnSignalingMessage(const std::string& msg) {}
+ virtual void OnSignalingChange(
+ PeerConnectionInterface::SignalingState new_state) {}
+ virtual void OnAddStream(MediaStreamInterface* stream) {}
+ virtual void OnRemoveStream(MediaStreamInterface* stream) {}
+ virtual void OnDataChannel(DataChannelInterface* data_channel) {}
+ virtual void OnRenegotiationNeeded() {}
+ virtual void OnIceConnectionChange(
+ PeerConnectionInterface::IceConnectionState new_state) {}
+ virtual void OnIceGatheringChange(
+ PeerConnectionInterface::IceGatheringState new_state) {}
+ virtual void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) {}
+};
+
+} // namespace
+
+class PeerConnectionFactoryTest : public testing::Test {
+ void SetUp() {
+#ifdef WEBRTC_ANDROID
+ webrtc::InitializeAndroidObjects();
+#endif
+ factory_ = webrtc::CreatePeerConnectionFactory(rtc::Thread::Current(),
+ rtc::Thread::Current(),
+ NULL,
+ NULL,
+ NULL);
+
+ ASSERT_TRUE(factory_.get() != NULL);
+ port_allocator_.reset(
+ new cricket::FakePortAllocator(rtc::Thread::Current(), nullptr));
+ raw_port_allocator_ = port_allocator_.get();
+ }
+
+ protected:
+ void VerifyStunServers(cricket::ServerAddresses stun_servers) {
+ EXPECT_EQ(stun_servers, raw_port_allocator_->stun_servers());
+ }
+
+ void VerifyTurnServers(std::vector<cricket::RelayServerConfig> turn_servers) {
+ EXPECT_EQ(turn_servers.size(), raw_port_allocator_->turn_servers().size());
+ for (size_t i = 0; i < turn_servers.size(); ++i) {
+ ASSERT_EQ(1u, turn_servers[i].ports.size());
+ EXPECT_EQ(1u, raw_port_allocator_->turn_servers()[i].ports.size());
+ EXPECT_EQ(
+ turn_servers[i].ports[0].address.ToString(),
+ raw_port_allocator_->turn_servers()[i].ports[0].address.ToString());
+ EXPECT_EQ(turn_servers[i].ports[0].proto,
+ raw_port_allocator_->turn_servers()[i].ports[0].proto);
+ EXPECT_EQ(turn_servers[i].credentials.username,
+ raw_port_allocator_->turn_servers()[i].credentials.username);
+ EXPECT_EQ(turn_servers[i].credentials.password,
+ raw_port_allocator_->turn_servers()[i].credentials.password);
+ }
+ }
+
+ rtc::scoped_refptr<PeerConnectionFactoryInterface> factory_;
+ NullPeerConnectionObserver observer_;
+ rtc::scoped_ptr<cricket::FakePortAllocator> port_allocator_;
+ // Since the PC owns the port allocator after it's been initialized,
+ // this should only be used when known to be safe.
+ cricket::FakePortAllocator* raw_port_allocator_;
+};
+
+// Verify creation of PeerConnection using internal ADM, video factory and
+// internal libjingle threads.
+TEST(PeerConnectionFactoryTestInternal, CreatePCUsingInternalModules) {
+#ifdef WEBRTC_ANDROID
+ webrtc::InitializeAndroidObjects();
+#endif
+
+ rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
+ webrtc::CreatePeerConnectionFactory());
+
+ NullPeerConnectionObserver observer;
+ webrtc::PeerConnectionInterface::RTCConfiguration config;
+
+ rtc::scoped_ptr<FakeDtlsIdentityStore> dtls_identity_store(
+ new FakeDtlsIdentityStore());
+ rtc::scoped_refptr<PeerConnectionInterface> pc(factory->CreatePeerConnection(
+ config, nullptr, nullptr, std::move(dtls_identity_store), &observer));
+
+ EXPECT_TRUE(pc.get() != nullptr);
+}
+
+// This test verifies creation of PeerConnection with valid STUN and TURN
+// configuration. Also verifies the URL's parsed correctly as expected.
+TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServers) {
+ PeerConnectionInterface::RTCConfiguration config;
+ webrtc::PeerConnectionInterface::IceServer ice_server;
+ ice_server.uri = kStunIceServer;
+ config.servers.push_back(ice_server);
+ ice_server.uri = kTurnIceServer;
+ ice_server.password = kTurnPassword;
+ config.servers.push_back(ice_server);
+ ice_server.uri = kTurnIceServerWithTransport;
+ ice_server.password = kTurnPassword;
+ config.servers.push_back(ice_server);
+ rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store(
+ new FakeDtlsIdentityStore());
+ rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection(
+ config, nullptr, std::move(port_allocator_),
+ std::move(dtls_identity_store), &observer_));
+ ASSERT_TRUE(pc.get() != NULL);
+ cricket::ServerAddresses stun_servers;
+ rtc::SocketAddress stun1("stun.l.google.com", 19302);
+ stun_servers.insert(stun1);
+ VerifyStunServers(stun_servers);
+ std::vector<cricket::RelayServerConfig> turn_servers;
+ cricket::RelayServerConfig turn1("test.com", 1234, "test@hello.com",
+ kTurnPassword, cricket::PROTO_UDP, false);
+ turn_servers.push_back(turn1);
+ cricket::RelayServerConfig turn2("hello.com", kDefaultStunPort, "test",
+ kTurnPassword, cricket::PROTO_TCP, false);
+ turn_servers.push_back(turn2);
+ VerifyTurnServers(turn_servers);
+}
+
+// This test verifies creation of PeerConnection with valid STUN and TURN
+// configuration. Also verifies the list of URL's parsed correctly as expected.
+TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServersUrls) {
+ PeerConnectionInterface::RTCConfiguration config;
+ webrtc::PeerConnectionInterface::IceServer ice_server;
+ ice_server.urls.push_back(kStunIceServer);
+ ice_server.urls.push_back(kTurnIceServer);
+ ice_server.urls.push_back(kTurnIceServerWithTransport);
+ ice_server.password = kTurnPassword;
+ config.servers.push_back(ice_server);
+ rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store(
+ new FakeDtlsIdentityStore());
+ rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection(
+ config, nullptr, std::move(port_allocator_),
+ std::move(dtls_identity_store), &observer_));
+ ASSERT_TRUE(pc.get() != NULL);
+ cricket::ServerAddresses stun_servers;
+ rtc::SocketAddress stun1("stun.l.google.com", 19302);
+ stun_servers.insert(stun1);
+ VerifyStunServers(stun_servers);
+ std::vector<cricket::RelayServerConfig> turn_servers;
+ cricket::RelayServerConfig turn1("test.com", 1234, "test@hello.com",
+ kTurnPassword, cricket::PROTO_UDP, false);
+ turn_servers.push_back(turn1);
+ cricket::RelayServerConfig turn2("hello.com", kDefaultStunPort, "test",
+ kTurnPassword, cricket::PROTO_TCP, false);
+ turn_servers.push_back(turn2);
+ VerifyTurnServers(turn_servers);
+}
+
+TEST_F(PeerConnectionFactoryTest, CreatePCUsingNoUsernameInUri) {
+ PeerConnectionInterface::RTCConfiguration config;
+ webrtc::PeerConnectionInterface::IceServer ice_server;
+ ice_server.uri = kStunIceServer;
+ config.servers.push_back(ice_server);
+ ice_server.uri = kTurnIceServerWithNoUsernameInUri;
+ ice_server.username = kTurnUsername;
+ ice_server.password = kTurnPassword;
+ config.servers.push_back(ice_server);
+ rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store(
+ new FakeDtlsIdentityStore());
+ rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection(
+ config, nullptr, std::move(port_allocator_),
+ std::move(dtls_identity_store), &observer_));
+ ASSERT_TRUE(pc.get() != NULL);
+ std::vector<cricket::RelayServerConfig> turn_servers;
+ cricket::RelayServerConfig turn("test.com", 1234, kTurnUsername,
+ kTurnPassword, cricket::PROTO_UDP, false);
+ turn_servers.push_back(turn);
+ VerifyTurnServers(turn_servers);
+}
+
+// This test verifies the PeerConnection created properly with TURN url which
+// has transport parameter in it.
+TEST_F(PeerConnectionFactoryTest, CreatePCUsingTurnUrlWithTransportParam) {
+ PeerConnectionInterface::RTCConfiguration config;
+ webrtc::PeerConnectionInterface::IceServer ice_server;
+ ice_server.uri = kTurnIceServerWithTransport;
+ ice_server.password = kTurnPassword;
+ config.servers.push_back(ice_server);
+ rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store(
+ new FakeDtlsIdentityStore());
+ rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection(
+ config, nullptr, std::move(port_allocator_),
+ std::move(dtls_identity_store), &observer_));
+ ASSERT_TRUE(pc.get() != NULL);
+ std::vector<cricket::RelayServerConfig> turn_servers;
+ cricket::RelayServerConfig turn("hello.com", kDefaultStunPort, "test",
+ kTurnPassword, cricket::PROTO_TCP, false);
+ turn_servers.push_back(turn);
+ VerifyTurnServers(turn_servers);
+}
+
+TEST_F(PeerConnectionFactoryTest, CreatePCUsingSecureTurnUrl) {
+ PeerConnectionInterface::RTCConfiguration config;
+ webrtc::PeerConnectionInterface::IceServer ice_server;
+ ice_server.uri = kSecureTurnIceServer;
+ ice_server.password = kTurnPassword;
+ config.servers.push_back(ice_server);
+ ice_server.uri = kSecureTurnIceServerWithoutTransportParam;
+ ice_server.password = kTurnPassword;
+ config.servers.push_back(ice_server);
+ ice_server.uri = kSecureTurnIceServerWithoutTransportAndPortParam;
+ ice_server.password = kTurnPassword;
+ config.servers.push_back(ice_server);
+ rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store(
+ new FakeDtlsIdentityStore());
+ rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection(
+ config, nullptr, std::move(port_allocator_),
+ std::move(dtls_identity_store), &observer_));
+ ASSERT_TRUE(pc.get() != NULL);
+ std::vector<cricket::RelayServerConfig> turn_servers;
+ cricket::RelayServerConfig turn1("hello.com", kDefaultStunTlsPort, "test",
+ kTurnPassword, cricket::PROTO_TCP, true);
+ turn_servers.push_back(turn1);
+ // TURNS with transport param should be default to tcp.
+ cricket::RelayServerConfig turn2("hello.com", 443, "test_no_transport",
+ kTurnPassword, cricket::PROTO_TCP, true);
+ turn_servers.push_back(turn2);
+ cricket::RelayServerConfig turn3("hello.com", kDefaultStunTlsPort,
+ "test_no_transport", kTurnPassword,
+ cricket::PROTO_TCP, true);
+ turn_servers.push_back(turn3);
+ VerifyTurnServers(turn_servers);
+}
+
+TEST_F(PeerConnectionFactoryTest, CreatePCUsingIPLiteralAddress) {
+ PeerConnectionInterface::RTCConfiguration config;
+ webrtc::PeerConnectionInterface::IceServer ice_server;
+ ice_server.uri = kStunIceServerWithIPv4Address;
+ config.servers.push_back(ice_server);
+ ice_server.uri = kStunIceServerWithIPv4AddressWithoutPort;
+ config.servers.push_back(ice_server);
+ ice_server.uri = kStunIceServerWithIPv6Address;
+ config.servers.push_back(ice_server);
+ ice_server.uri = kStunIceServerWithIPv6AddressWithoutPort;
+ config.servers.push_back(ice_server);
+ ice_server.uri = kTurnIceServerWithIPv6Address;
+ ice_server.password = kTurnPassword;
+ config.servers.push_back(ice_server);
+ rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store(
+ new FakeDtlsIdentityStore());
+ rtc::scoped_refptr<PeerConnectionInterface> pc(factory_->CreatePeerConnection(
+ config, nullptr, std::move(port_allocator_),
+ std::move(dtls_identity_store), &observer_));
+ ASSERT_TRUE(pc.get() != NULL);
+ cricket::ServerAddresses stun_servers;
+ rtc::SocketAddress stun1("1.2.3.4", 1234);
+ stun_servers.insert(stun1);
+ rtc::SocketAddress stun2("1.2.3.4", 3478);
+ stun_servers.insert(stun2); // Default port
+ rtc::SocketAddress stun3("2401:fa00:4::", 1234);
+ stun_servers.insert(stun3);
+ rtc::SocketAddress stun4("2401:fa00:4::", 3478);
+ stun_servers.insert(stun4); // Default port
+ VerifyStunServers(stun_servers);
+
+ std::vector<cricket::RelayServerConfig> turn_servers;
+ cricket::RelayServerConfig turn1("2401:fa00:4::", 1234, "test", kTurnPassword,
+ cricket::PROTO_UDP, false);
+ turn_servers.push_back(turn1);
+ VerifyTurnServers(turn_servers);
+}
+
+// This test verifies the captured stream is rendered locally using a
+// local video track.
+TEST_F(PeerConnectionFactoryTest, LocalRendering) {
+ cricket::FakeVideoCapturer* capturer = new cricket::FakeVideoCapturer();
+ // The source take ownership of |capturer|.
+ rtc::scoped_refptr<VideoSourceInterface> source(
+ factory_->CreateVideoSource(capturer, NULL));
+ ASSERT_TRUE(source.get() != NULL);
+ rtc::scoped_refptr<VideoTrackInterface> track(
+ factory_->CreateVideoTrack("testlabel", source));
+ ASSERT_TRUE(track.get() != NULL);
+ FakeVideoTrackRenderer local_renderer(track);
+
+ EXPECT_EQ(0, local_renderer.num_rendered_frames());
+ EXPECT_TRUE(capturer->CaptureFrame());
+ EXPECT_EQ(1, local_renderer.num_rendered_frames());
+ EXPECT_FALSE(local_renderer.black_frame());
+
+ track->set_enabled(false);
+ EXPECT_TRUE(capturer->CaptureFrame());
+ EXPECT_EQ(2, local_renderer.num_rendered_frames());
+ EXPECT_TRUE(local_renderer.black_frame());
+
+ track->set_enabled(true);
+ EXPECT_TRUE(capturer->CaptureFrame());
+ EXPECT_EQ(3, local_renderer.num_rendered_frames());
+ EXPECT_FALSE(local_renderer.black_frame());
+}