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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: webrtc/p2p/base/transportcontroller_unittest.cc

Issue 2648233003: Adding ability for BaseChannel to use PacketTransportInterface. (Closed)
Patch Set: Fix TSAN warning in test by starting thread after setting fake clock 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 side-by-side diff with in-line comments
Download patch
« no previous file with comments | « webrtc/p2p/base/jseptransport_unittest.cc ('k') | webrtc/pc/channel.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: webrtc/p2p/base/transportcontroller_unittest.cc
diff --git a/webrtc/p2p/base/transportcontroller_unittest.cc b/webrtc/p2p/base/transportcontroller_unittest.cc
index 1fc71f1274c45aa1e81d4635e00373c42471c42c..6ea83a48098ce2af6514e0ebc83100ef350f3b8a 100644
--- a/webrtc/p2p/base/transportcontroller_unittest.cc
+++ b/webrtc/p2p/base/transportcontroller_unittest.cc
@@ -34,11 +34,10 @@ static const char kIcePwd3[] = "TESTICEPWD00000000000003";
namespace cricket {
// Only subclassing from FakeTransportController because currently that's the
-// only way to have a TransportController with fake TransportChannels.
+// only way to have a TransportController with fake ICE/DTLS transports.
//
-// TODO(deadbeef): Change this once the Transport/TransportChannel class
-// heirarchy is cleaned up, and we can pass a "TransportChannelFactory" or
-// something similar into TransportController.
+// TODO(deadbeef): Pass a "TransportFactory" or something similar into
+// TransportController, instead of using inheritance in this way for testing.
typedef FakeTransportController TransportControllerForTest;
class TransportControllerTest : public testing::Test,
@@ -71,13 +70,14 @@ class TransportControllerTest : public testing::Test,
this, &TransportControllerTest::OnCandidatesGathered);
}
- FakeDtlsTransport* CreateChannel(const std::string& content, int component) {
- DtlsTransportInternal* channel =
+ FakeDtlsTransport* CreateFakeDtlsTransport(const std::string& content,
+ int component) {
+ DtlsTransportInternal* transport =
transport_controller_->CreateDtlsTransport_n(content, component);
- return static_cast<FakeDtlsTransport*>(channel);
+ return static_cast<FakeDtlsTransport*>(transport);
}
- void DestroyChannel(const std::string& content, int component) {
+ void DestroyFakeDtlsTransport(const std::string& content, int component) {
transport_controller_->DestroyDtlsTransport_n(content, component);
}
@@ -91,20 +91,20 @@ class TransportControllerTest : public testing::Test,
}
// Used for thread hopping test.
- void CreateChannelsAndCompleteConnectionOnNetworkThread() {
+ void CreateFakeDtlsTransportsAndCompleteConnectionOnNetworkThread() {
network_thread_->Invoke<void>(
RTC_FROM_HERE,
- rtc::Bind(
- &TransportControllerTest::CreateChannelsAndCompleteConnection_w,
- this));
+ rtc::Bind(&TransportControllerTest::
+ CreateFakeDtlsTransportsAndCompleteConnection_w,
+ this));
}
- void CreateChannelsAndCompleteConnection_w() {
+ void CreateFakeDtlsTransportsAndCompleteConnection_w() {
transport_controller_->SetIceRole(ICEROLE_CONTROLLING);
- FakeDtlsTransport* channel1 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel1);
- FakeDtlsTransport* channel2 = CreateChannel("video", 1);
- ASSERT_NE(nullptr, channel2);
+ FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport1);
+ FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("video", 1);
+ ASSERT_NE(nullptr, transport2);
TransportDescription local_desc(std::vector<std::string>(), kIceUfrag1,
kIcePwd1, ICEMODE_FULL,
@@ -115,20 +115,20 @@ class TransportControllerTest : public testing::Test,
transport_controller_->SetLocalTransportDescription("video", local_desc,
CA_OFFER, &err);
transport_controller_->MaybeStartGathering();
- channel1->ice_transport()->SignalCandidateGathered(
- channel1->ice_transport(), CreateCandidate(1));
- channel2->ice_transport()->SignalCandidateGathered(
- channel2->ice_transport(), CreateCandidate(1));
- channel1->SetCandidatesGatheringComplete();
- channel2->SetCandidatesGatheringComplete();
- channel1->SetConnectionCount(2);
- channel2->SetConnectionCount(2);
- channel1->SetReceiving(true);
- channel2->SetReceiving(true);
- channel1->SetWritable(true);
- channel2->SetWritable(true);
- channel1->SetConnectionCount(1);
- channel2->SetConnectionCount(1);
+ transport1->fake_ice_transport()->SignalCandidateGathered(
+ transport1->fake_ice_transport(), CreateCandidate(1));
+ transport2->fake_ice_transport()->SignalCandidateGathered(
+ transport2->fake_ice_transport(), CreateCandidate(1));
+ transport1->fake_ice_transport()->SetCandidatesGatheringComplete();
+ transport2->fake_ice_transport()->SetCandidatesGatheringComplete();
+ transport1->fake_ice_transport()->SetConnectionCount(2);
+ transport2->fake_ice_transport()->SetConnectionCount(2);
+ transport1->SetReceiving(true);
+ transport2->SetReceiving(true);
+ transport1->SetWritable(true);
+ transport2->SetWritable(true);
+ transport1->fake_ice_transport()->SetConnectionCount(1);
+ transport2->fake_ice_transport()->SetConnectionCount(1);
}
IceConfig CreateIceConfig(
@@ -196,30 +196,30 @@ class TransportControllerTest : public testing::Test,
};
TEST_F(TransportControllerTest, TestSetIceConfig) {
- FakeDtlsTransport* channel1 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel1);
+ FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport1);
transport_controller_->SetIceConfig(
CreateIceConfig(1000, GATHER_CONTINUALLY));
- EXPECT_EQ(1000, channel1->receiving_timeout());
- EXPECT_TRUE(channel1->gather_continually());
+ EXPECT_EQ(1000, transport1->fake_ice_transport()->receiving_timeout());
+ EXPECT_TRUE(transport1->fake_ice_transport()->gather_continually());
transport_controller_->SetIceConfig(
CreateIceConfig(1000, GATHER_CONTINUALLY_AND_RECOVER));
- // Test that value stored in controller is applied to new channels.
- FakeDtlsTransport* channel2 = CreateChannel("video", 1);
- ASSERT_NE(nullptr, channel2);
- EXPECT_EQ(1000, channel2->receiving_timeout());
- EXPECT_TRUE(channel2->gather_continually());
+ // Test that value stored in controller is applied to new transports.
+ FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("video", 1);
+ ASSERT_NE(nullptr, transport2);
+ EXPECT_EQ(1000, transport2->fake_ice_transport()->receiving_timeout());
+ EXPECT_TRUE(transport2->fake_ice_transport()->gather_continually());
}
TEST_F(TransportControllerTest, TestSetSslMaxProtocolVersion) {
EXPECT_TRUE(transport_controller_->SetSslMaxProtocolVersion(
rtc::SSL_PROTOCOL_DTLS_12));
- FakeDtlsTransport* channel = CreateChannel("audio", 1);
+ FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
- ASSERT_NE(nullptr, channel);
- EXPECT_EQ(rtc::SSL_PROTOCOL_DTLS_12, channel->ssl_max_protocol_version());
+ ASSERT_NE(nullptr, transport);
+ EXPECT_EQ(rtc::SSL_PROTOCOL_DTLS_12, transport->ssl_max_protocol_version());
// Setting max version after transport is created should fail.
EXPECT_FALSE(transport_controller_->SetSslMaxProtocolVersion(
@@ -227,47 +227,54 @@ TEST_F(TransportControllerTest, TestSetSslMaxProtocolVersion) {
}
TEST_F(TransportControllerTest, TestSetIceRole) {
- FakeDtlsTransport* channel1 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel1);
+ FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport1);
transport_controller_->SetIceRole(ICEROLE_CONTROLLING);
- EXPECT_EQ(ICEROLE_CONTROLLING, channel1->GetIceRole());
+ EXPECT_EQ(ICEROLE_CONTROLLING,
+ transport1->fake_ice_transport()->GetIceRole());
transport_controller_->SetIceRole(ICEROLE_CONTROLLED);
- EXPECT_EQ(ICEROLE_CONTROLLED, channel1->GetIceRole());
+ EXPECT_EQ(ICEROLE_CONTROLLED, transport1->fake_ice_transport()->GetIceRole());
- // Test that value stored in controller is applied to new channels.
- FakeDtlsTransport* channel2 = CreateChannel("video", 1);
- ASSERT_NE(nullptr, channel2);
- EXPECT_EQ(ICEROLE_CONTROLLED, channel2->GetIceRole());
+ // Test that value stored in controller is applied to new transports.
+ FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("video", 1);
+ ASSERT_NE(nullptr, transport2);
+ EXPECT_EQ(ICEROLE_CONTROLLED, transport2->fake_ice_transport()->GetIceRole());
}
-// Test that when one channel encounters a role conflict, the ICE role is
-// swapped on every channel.
+// Test that when one transport encounters a role conflict, the ICE role is
+// swapped on every transport.
TEST_F(TransportControllerTest, TestIceRoleConflict) {
- FakeDtlsTransport* channel1 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel1);
- FakeDtlsTransport* channel2 = CreateChannel("video", 1);
- ASSERT_NE(nullptr, channel2);
+ FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport1);
+ FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("video", 1);
+ ASSERT_NE(nullptr, transport2);
transport_controller_->SetIceRole(ICEROLE_CONTROLLING);
- EXPECT_EQ(ICEROLE_CONTROLLING, channel1->GetIceRole());
- EXPECT_EQ(ICEROLE_CONTROLLING, channel2->GetIceRole());
+ EXPECT_EQ(ICEROLE_CONTROLLING,
+ transport1->fake_ice_transport()->GetIceRole());
+ EXPECT_EQ(ICEROLE_CONTROLLING,
+ transport2->fake_ice_transport()->GetIceRole());
- channel1->ice_transport()->SignalRoleConflict(channel1->ice_transport());
- EXPECT_EQ(ICEROLE_CONTROLLED, channel1->GetIceRole());
- EXPECT_EQ(ICEROLE_CONTROLLED, channel2->GetIceRole());
+ transport1->fake_ice_transport()->SignalRoleConflict(
+ transport1->fake_ice_transport());
+ EXPECT_EQ(ICEROLE_CONTROLLED, transport1->fake_ice_transport()->GetIceRole());
+ EXPECT_EQ(ICEROLE_CONTROLLED, transport2->fake_ice_transport()->GetIceRole());
// Should be able to handle a second role conflict. The remote endpoint can
// change its role/tie-breaker when it does an ICE restart.
- channel2->ice_transport()->SignalRoleConflict(channel2->ice_transport());
- EXPECT_EQ(ICEROLE_CONTROLLING, channel1->GetIceRole());
- EXPECT_EQ(ICEROLE_CONTROLLING, channel2->GetIceRole());
+ transport2->fake_ice_transport()->SignalRoleConflict(
+ transport2->fake_ice_transport());
+ EXPECT_EQ(ICEROLE_CONTROLLING,
+ transport1->fake_ice_transport()->GetIceRole());
+ EXPECT_EQ(ICEROLE_CONTROLLING,
+ transport2->fake_ice_transport()->GetIceRole());
}
TEST_F(TransportControllerTest, TestGetSslRole) {
- FakeDtlsTransport* channel = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel);
- ASSERT_TRUE(channel->SetSslRole(rtc::SSL_CLIENT));
+ FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport);
+ ASSERT_TRUE(transport->SetSslRole(rtc::SSL_CLIENT));
rtc::SSLRole role;
EXPECT_FALSE(transport_controller_->GetSslRole("video", &role));
EXPECT_TRUE(transport_controller_->GetSslRole("audio", &role));
@@ -283,8 +290,8 @@ TEST_F(TransportControllerTest, TestSetAndGetLocalCertificate) {
rtc::SSLIdentity::Generate("session2", rtc::KT_DEFAULT)));
rtc::scoped_refptr<rtc::RTCCertificate> returned_certificate;
- FakeDtlsTransport* channel1 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel1);
+ FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport1);
EXPECT_TRUE(transport_controller_->SetLocalCertificate(certificate1));
EXPECT_TRUE(transport_controller_->GetLocalCertificate(
@@ -296,9 +303,9 @@ TEST_F(TransportControllerTest, TestSetAndGetLocalCertificate) {
EXPECT_FALSE(transport_controller_->GetLocalCertificate(
"video", &returned_certificate));
- // Test that identity stored in controller is applied to new channels.
- FakeDtlsTransport* channel2 = CreateChannel("video", 1);
- ASSERT_NE(nullptr, channel2);
+ // Test that identity stored in controller is applied to new transports.
+ FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("video", 1);
+ ASSERT_NE(nullptr, transport2);
EXPECT_TRUE(transport_controller_->GetLocalCertificate(
"video", &returned_certificate));
EXPECT_EQ(certificate1->identity()->certificate().ToPEMString(),
@@ -311,10 +318,10 @@ TEST_F(TransportControllerTest, TestSetAndGetLocalCertificate) {
TEST_F(TransportControllerTest, TestGetRemoteSSLCertificate) {
rtc::FakeSSLCertificate fake_certificate("fake_data");
- FakeDtlsTransport* channel = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel);
+ FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport);
- channel->SetRemoteSSLCertificate(&fake_certificate);
+ transport->SetRemoteSSLCertificate(&fake_certificate);
std::unique_ptr<rtc::SSLCertificate> returned_certificate =
transport_controller_->GetRemoteSSLCertificate("audio");
EXPECT_TRUE(returned_certificate);
@@ -326,17 +333,17 @@ TEST_F(TransportControllerTest, TestGetRemoteSSLCertificate) {
}
TEST_F(TransportControllerTest, TestSetLocalTransportDescription) {
- FakeDtlsTransport* channel = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel);
+ FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport);
TransportDescription local_desc(std::vector<std::string>(), kIceUfrag1,
kIcePwd1, ICEMODE_FULL,
CONNECTIONROLE_ACTPASS, nullptr);
std::string err;
EXPECT_TRUE(transport_controller_->SetLocalTransportDescription(
"audio", local_desc, CA_OFFER, &err));
- // Check that ICE ufrag and pwd were propagated to channel.
- EXPECT_EQ(kIceUfrag1, channel->ice_ufrag());
- EXPECT_EQ(kIcePwd1, channel->ice_pwd());
+ // Check that ICE ufrag and pwd were propagated to transport.
+ EXPECT_EQ(kIceUfrag1, transport->fake_ice_transport()->ice_ufrag());
+ EXPECT_EQ(kIcePwd1, transport->fake_ice_transport()->ice_pwd());
// After setting local description, we should be able to start gathering
// candidates.
transport_controller_->MaybeStartGathering();
@@ -345,33 +352,33 @@ TEST_F(TransportControllerTest, TestSetLocalTransportDescription) {
}
TEST_F(TransportControllerTest, TestSetRemoteTransportDescription) {
- FakeDtlsTransport* channel = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel);
+ FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport);
TransportDescription remote_desc(std::vector<std::string>(), kIceUfrag1,
kIcePwd1, ICEMODE_FULL,
CONNECTIONROLE_ACTPASS, nullptr);
std::string err;
EXPECT_TRUE(transport_controller_->SetRemoteTransportDescription(
"audio", remote_desc, CA_OFFER, &err));
- // Check that ICE ufrag and pwd were propagated to channel.
- EXPECT_EQ(kIceUfrag1, channel->remote_ice_ufrag());
- EXPECT_EQ(kIcePwd1, channel->remote_ice_pwd());
+ // Check that ICE ufrag and pwd were propagated to transport.
+ EXPECT_EQ(kIceUfrag1, transport->fake_ice_transport()->remote_ice_ufrag());
+ EXPECT_EQ(kIcePwd1, transport->fake_ice_transport()->remote_ice_pwd());
}
TEST_F(TransportControllerTest, TestAddRemoteCandidates) {
- FakeDtlsTransport* channel = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel);
+ FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport);
Candidates candidates;
candidates.push_back(CreateCandidate(1));
std::string err;
EXPECT_TRUE(
transport_controller_->AddRemoteCandidates("audio", candidates, &err));
- EXPECT_EQ(1U, channel->remote_candidates().size());
+ EXPECT_EQ(1U, transport->fake_ice_transport()->remote_candidates().size());
}
TEST_F(TransportControllerTest, TestReadyForRemoteCandidates) {
- FakeDtlsTransport* channel = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel);
+ FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport);
// We expect to be ready for remote candidates only after local and remote
// descriptions are set.
EXPECT_FALSE(transport_controller_->ReadyForRemoteCandidates("audio"));
@@ -393,12 +400,12 @@ TEST_F(TransportControllerTest, TestReadyForRemoteCandidates) {
}
TEST_F(TransportControllerTest, TestGetStats) {
- FakeDtlsTransport* channel1 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel1);
- FakeDtlsTransport* channel2 = CreateChannel("audio", 2);
- ASSERT_NE(nullptr, channel2);
- FakeDtlsTransport* channel3 = CreateChannel("video", 1);
- ASSERT_NE(nullptr, channel3);
+ FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport1);
+ FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("audio", 2);
+ ASSERT_NE(nullptr, transport2);
+ FakeDtlsTransport* transport3 = CreateFakeDtlsTransport("video", 1);
+ ASSERT_NE(nullptr, transport3);
TransportStats stats;
EXPECT_TRUE(transport_controller_->GetStats("audio", &stats));
@@ -406,113 +413,115 @@ TEST_F(TransportControllerTest, TestGetStats) {
EXPECT_EQ(2U, stats.channel_stats.size());
}
-// Test that transport gets destroyed when it has no more channels.
-TEST_F(TransportControllerTest, TestCreateAndDestroyChannel) {
- FakeDtlsTransport* channel1 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel1);
- FakeDtlsTransport* channel2 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel2);
- ASSERT_EQ(channel1, channel2);
- FakeDtlsTransport* channel3 = CreateChannel("audio", 2);
- ASSERT_NE(nullptr, channel3);
+// Test that a "transport" from a stats perspective (combination of RTP/RTCP
+// transports) goes away when all references to its transports are gone.
+TEST_F(TransportControllerTest, TestCreateAndDestroyFakeDtlsTransport) {
+ FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport1);
+ FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport2);
+ ASSERT_EQ(transport1, transport2);
+ FakeDtlsTransport* transport3 = CreateFakeDtlsTransport("audio", 2);
+ ASSERT_NE(nullptr, transport3);
// Using GetStats to check if transport is destroyed from an outside class's
// perspective.
TransportStats stats;
EXPECT_TRUE(transport_controller_->GetStats("audio", &stats));
- DestroyChannel("audio", 2);
- DestroyChannel("audio", 1);
+ DestroyFakeDtlsTransport("audio", 2);
+ DestroyFakeDtlsTransport("audio", 1);
EXPECT_TRUE(transport_controller_->GetStats("audio", &stats));
- DestroyChannel("audio", 1);
+ DestroyFakeDtlsTransport("audio", 1);
EXPECT_FALSE(transport_controller_->GetStats("audio", &stats));
}
TEST_F(TransportControllerTest, TestSignalConnectionStateFailed) {
// Need controlling ICE role to get in failed state.
transport_controller_->SetIceRole(ICEROLE_CONTROLLING);
- FakeDtlsTransport* channel1 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel1);
- FakeDtlsTransport* channel2 = CreateChannel("video", 1);
- ASSERT_NE(nullptr, channel2);
+ FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport1);
+ FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("video", 1);
+ ASSERT_NE(nullptr, transport2);
- // Should signal "failed" if any channel failed; channel is considered failed
+ // Should signal "failed" if any transport failed; transport is considered
+ // failed
// if it previously had a connection but now has none, and gathering is
// complete.
- channel1->SetCandidatesGatheringComplete();
- channel1->SetConnectionCount(1);
- channel1->SetConnectionCount(0);
+ transport1->fake_ice_transport()->SetCandidatesGatheringComplete();
+ transport1->fake_ice_transport()->SetConnectionCount(1);
+ transport1->fake_ice_transport()->SetConnectionCount(0);
EXPECT_EQ_WAIT(kIceConnectionFailed, connection_state_, kTimeout);
EXPECT_EQ(1, connection_state_signal_count_);
}
TEST_F(TransportControllerTest, TestSignalConnectionStateConnected) {
transport_controller_->SetIceRole(ICEROLE_CONTROLLING);
- FakeDtlsTransport* channel1 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel1);
- FakeDtlsTransport* channel2 = CreateChannel("video", 1);
- ASSERT_NE(nullptr, channel2);
- FakeDtlsTransport* channel3 = CreateChannel("video", 2);
- ASSERT_NE(nullptr, channel3);
-
- // First, have one channel connect, and another fail, to ensure that
- // the first channel connecting didn't trigger a "connected" state signal.
+ FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport1);
+ FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("video", 1);
+ ASSERT_NE(nullptr, transport2);
+ FakeDtlsTransport* transport3 = CreateFakeDtlsTransport("video", 2);
+ ASSERT_NE(nullptr, transport3);
+
+ // First, have one transport connect, and another fail, to ensure that
+ // the first transport connecting didn't trigger a "connected" state signal.
// We should only get a signal when all are connected.
- channel1->SetConnectionCount(2);
- channel1->SetWritable(true);
- channel3->SetCandidatesGatheringComplete();
- channel3->SetConnectionCount(1);
- channel3->SetConnectionCount(0);
+ transport1->fake_ice_transport()->SetConnectionCount(2);
+ transport1->SetWritable(true);
+ transport3->fake_ice_transport()->SetCandidatesGatheringComplete();
+ transport3->fake_ice_transport()->SetConnectionCount(1);
+ transport3->fake_ice_transport()->SetConnectionCount(0);
EXPECT_EQ_WAIT(kIceConnectionFailed, connection_state_, kTimeout);
// Signal count of 1 means that the only signal emitted was "failed".
EXPECT_EQ(1, connection_state_signal_count_);
- // Destroy the failed channel to return to "connecting" state.
- DestroyChannel("video", 2);
+ // Destroy the failed transport to return to "connecting" state.
+ DestroyFakeDtlsTransport("video", 2);
EXPECT_EQ_WAIT(kIceConnectionConnecting, connection_state_, kTimeout);
EXPECT_EQ(2, connection_state_signal_count_);
- // Make the remaining channel reach a connected state.
- channel2->SetConnectionCount(2);
- channel2->SetWritable(true);
+ // Make the remaining transport reach a connected state.
+ transport2->fake_ice_transport()->SetConnectionCount(2);
+ transport2->SetWritable(true);
EXPECT_EQ_WAIT(kIceConnectionConnected, connection_state_, kTimeout);
EXPECT_EQ(3, connection_state_signal_count_);
}
TEST_F(TransportControllerTest, TestSignalConnectionStateComplete) {
transport_controller_->SetIceRole(ICEROLE_CONTROLLING);
- FakeDtlsTransport* channel1 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel1);
- FakeDtlsTransport* channel2 = CreateChannel("video", 1);
- ASSERT_NE(nullptr, channel2);
- FakeDtlsTransport* channel3 = CreateChannel("video", 2);
- ASSERT_NE(nullptr, channel3);
+ FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport1);
+ FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("video", 1);
+ ASSERT_NE(nullptr, transport2);
+ FakeDtlsTransport* transport3 = CreateFakeDtlsTransport("video", 2);
+ ASSERT_NE(nullptr, transport3);
// Similar to above test, but we're now reaching the completed state, which
// means only one connection per FakeDtlsTransport.
- channel1->SetCandidatesGatheringComplete();
- channel1->SetConnectionCount(1);
- channel1->SetWritable(true);
- channel3->SetCandidatesGatheringComplete();
- channel3->SetConnectionCount(1);
- channel3->SetConnectionCount(0);
+ transport1->fake_ice_transport()->SetCandidatesGatheringComplete();
+ transport1->fake_ice_transport()->SetConnectionCount(1);
+ transport1->SetWritable(true);
+ transport3->fake_ice_transport()->SetCandidatesGatheringComplete();
+ transport3->fake_ice_transport()->SetConnectionCount(1);
+ transport3->fake_ice_transport()->SetConnectionCount(0);
EXPECT_EQ_WAIT(kIceConnectionFailed, connection_state_, kTimeout);
// Signal count of 1 means that the only signal emitted was "failed".
EXPECT_EQ(1, connection_state_signal_count_);
- // Destroy the failed channel to return to "connecting" state.
- DestroyChannel("video", 2);
+ // Destroy the failed transport to return to "connecting" state.
+ DestroyFakeDtlsTransport("video", 2);
EXPECT_EQ_WAIT(kIceConnectionConnecting, connection_state_, kTimeout);
EXPECT_EQ(2, connection_state_signal_count_);
- // Make the remaining channel reach a connected state.
- channel2->SetCandidatesGatheringComplete();
- channel2->SetConnectionCount(2);
- channel2->SetWritable(true);
+ // Make the remaining transport reach a connected state.
+ transport2->fake_ice_transport()->SetCandidatesGatheringComplete();
+ transport2->fake_ice_transport()->SetConnectionCount(2);
+ transport2->SetWritable(true);
EXPECT_EQ_WAIT(kIceConnectionConnected, connection_state_, kTimeout);
EXPECT_EQ(3, connection_state_signal_count_);
// Finally, transition to completed state.
- channel2->SetConnectionCount(1);
+ transport2->fake_ice_transport()->SetConnectionCount(1);
EXPECT_EQ_WAIT(kIceConnectionCompleted, connection_state_, kTimeout);
EXPECT_EQ(4, connection_state_signal_count_);
}
@@ -520,24 +529,24 @@ TEST_F(TransportControllerTest, TestSignalConnectionStateComplete) {
// Make sure that if we're "connected" and remove a transport, we stay in the
// "connected" state.
TEST_F(TransportControllerTest, TestDestroyTransportAndStayConnected) {
- FakeDtlsTransport* channel1 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel1);
- FakeDtlsTransport* channel2 = CreateChannel("video", 1);
- ASSERT_NE(nullptr, channel2);
-
- channel1->SetCandidatesGatheringComplete();
- channel1->SetConnectionCount(2);
- channel1->SetWritable(true);
- channel2->SetCandidatesGatheringComplete();
- channel2->SetConnectionCount(2);
- channel2->SetWritable(true);
+ FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport1);
+ FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("video", 1);
+ ASSERT_NE(nullptr, transport2);
+
+ transport1->fake_ice_transport()->SetCandidatesGatheringComplete();
+ transport1->fake_ice_transport()->SetConnectionCount(2);
+ transport1->SetWritable(true);
+ transport2->fake_ice_transport()->SetCandidatesGatheringComplete();
+ transport2->fake_ice_transport()->SetConnectionCount(2);
+ transport2->SetWritable(true);
EXPECT_EQ_WAIT(kIceConnectionConnected, connection_state_, kTimeout);
EXPECT_EQ(1, connection_state_signal_count_);
- // Destroy one channel, then "complete" the other one, so we reach
+ // Destroy one transport, then "complete" the other one, so we reach
// a known state.
- DestroyChannel("video", 1);
- channel1->SetConnectionCount(1);
+ DestroyFakeDtlsTransport("video", 1);
+ transport1->fake_ice_transport()->SetConnectionCount(1);
EXPECT_EQ_WAIT(kIceConnectionCompleted, connection_state_, kTimeout);
// Signal count of 2 means the deletion didn't cause any unexpected signals
EXPECT_EQ(2, connection_state_signal_count_);
@@ -546,75 +555,76 @@ TEST_F(TransportControllerTest, TestDestroyTransportAndStayConnected) {
// If we destroy the last/only transport, we should simply transition to
// "connecting".
TEST_F(TransportControllerTest, TestDestroyLastTransportWhileConnected) {
- FakeDtlsTransport* channel = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel);
+ FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport);
- channel->SetCandidatesGatheringComplete();
- channel->SetConnectionCount(2);
- channel->SetWritable(true);
+ transport->fake_ice_transport()->SetCandidatesGatheringComplete();
+ transport->fake_ice_transport()->SetConnectionCount(2);
+ transport->SetWritable(true);
EXPECT_EQ_WAIT(kIceConnectionConnected, connection_state_, kTimeout);
EXPECT_EQ(1, connection_state_signal_count_);
- DestroyChannel("audio", 1);
+ DestroyFakeDtlsTransport("audio", 1);
EXPECT_EQ_WAIT(kIceConnectionConnecting, connection_state_, kTimeout);
// Signal count of 2 means the deletion didn't cause any unexpected signals
EXPECT_EQ(2, connection_state_signal_count_);
}
TEST_F(TransportControllerTest, TestSignalReceiving) {
- FakeDtlsTransport* channel1 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel1);
- FakeDtlsTransport* channel2 = CreateChannel("video", 1);
- ASSERT_NE(nullptr, channel2);
+ FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport1);
+ FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("video", 1);
+ ASSERT_NE(nullptr, transport2);
- // Should signal receiving as soon as any channel is receiving.
- channel1->SetReceiving(true);
+ // Should signal receiving as soon as any transport is receiving.
+ transport1->SetReceiving(true);
EXPECT_TRUE_WAIT(receiving_, kTimeout);
EXPECT_EQ(1, receiving_signal_count_);
- channel2->SetReceiving(true);
- channel1->SetReceiving(false);
- channel2->SetReceiving(false);
+ transport2->SetReceiving(true);
+ transport1->SetReceiving(false);
+ transport2->SetReceiving(false);
EXPECT_TRUE_WAIT(!receiving_, kTimeout);
EXPECT_EQ(2, receiving_signal_count_);
}
TEST_F(TransportControllerTest, TestSignalGatheringStateGathering) {
- FakeDtlsTransport* channel = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel);
- channel->ice_transport()->MaybeStartGathering();
+ FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport);
+ transport->fake_ice_transport()->MaybeStartGathering();
// Should be in the gathering state as soon as any transport starts gathering.
EXPECT_EQ_WAIT(kIceGatheringGathering, gathering_state_, kTimeout);
EXPECT_EQ(1, gathering_state_signal_count_);
}
TEST_F(TransportControllerTest, TestSignalGatheringStateComplete) {
- FakeDtlsTransport* channel1 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel1);
- FakeDtlsTransport* channel2 = CreateChannel("video", 1);
- ASSERT_NE(nullptr, channel2);
- FakeDtlsTransport* channel3 = CreateChannel("data", 1);
- ASSERT_NE(nullptr, channel3);
-
- channel3->ice_transport()->MaybeStartGathering();
+ FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport1);
+ FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("video", 1);
+ ASSERT_NE(nullptr, transport2);
+ FakeDtlsTransport* transport3 = CreateFakeDtlsTransport("data", 1);
+ ASSERT_NE(nullptr, transport3);
+
+ transport3->fake_ice_transport()->MaybeStartGathering();
EXPECT_EQ_WAIT(kIceGatheringGathering, gathering_state_, kTimeout);
EXPECT_EQ(1, gathering_state_signal_count_);
- // Have one channel finish gathering, then destroy it, to make sure gathering
+ // Have one transport finish gathering, then destroy it, to make sure
+ // gathering
// completion wasn't signalled if only one transport finished gathering.
- channel3->SetCandidatesGatheringComplete();
- DestroyChannel("data", 1);
+ transport3->fake_ice_transport()->SetCandidatesGatheringComplete();
+ DestroyFakeDtlsTransport("data", 1);
EXPECT_EQ_WAIT(kIceGatheringNew, gathering_state_, kTimeout);
EXPECT_EQ(2, gathering_state_signal_count_);
- // Make remaining channels start and then finish gathering.
- channel1->ice_transport()->MaybeStartGathering();
- channel2->ice_transport()->MaybeStartGathering();
+ // Make remaining transports start and then finish gathering.
+ transport1->fake_ice_transport()->MaybeStartGathering();
+ transport2->fake_ice_transport()->MaybeStartGathering();
EXPECT_EQ_WAIT(kIceGatheringGathering, gathering_state_, kTimeout);
EXPECT_EQ(3, gathering_state_signal_count_);
- channel1->SetCandidatesGatheringComplete();
- channel2->SetCandidatesGatheringComplete();
+ transport1->fake_ice_transport()->SetCandidatesGatheringComplete();
+ transport2->fake_ice_transport()->SetCandidatesGatheringComplete();
EXPECT_EQ_WAIT(kIceGatheringComplete, gathering_state_, kTimeout);
EXPECT_EQ(4, gathering_state_signal_count_);
}
@@ -626,18 +636,18 @@ TEST_F(TransportControllerTest, TestSignalGatheringStateComplete) {
TEST_F(TransportControllerTest,
TestSignalingWhenLastIncompleteTransportDestroyed) {
transport_controller_->SetIceRole(ICEROLE_CONTROLLING);
- FakeDtlsTransport* channel1 = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel1);
- FakeDtlsTransport* channel2 = CreateChannel("video", 1);
- ASSERT_NE(nullptr, channel2);
+ FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport1);
+ FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("video", 1);
+ ASSERT_NE(nullptr, transport2);
- channel1->SetCandidatesGatheringComplete();
+ transport1->fake_ice_transport()->SetCandidatesGatheringComplete();
EXPECT_EQ_WAIT(kIceGatheringGathering, gathering_state_, kTimeout);
EXPECT_EQ(1, gathering_state_signal_count_);
- channel1->SetConnectionCount(1);
- channel1->SetWritable(true);
- DestroyChannel("video", 1);
+ transport1->fake_ice_transport()->SetConnectionCount(1);
+ transport1->SetWritable(true);
+ DestroyFakeDtlsTransport("video", 1);
EXPECT_EQ_WAIT(kIceConnectionCompleted, connection_state_, kTimeout);
EXPECT_EQ(1, connection_state_signal_count_);
EXPECT_EQ_WAIT(kIceGatheringComplete, gathering_state_, kTimeout);
@@ -645,8 +655,8 @@ TEST_F(TransportControllerTest,
}
TEST_F(TransportControllerTest, TestSignalCandidatesGathered) {
- FakeDtlsTransport* channel = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel);
+ FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport);
// Transport won't signal candidates until it has a local description.
TransportDescription local_desc(std::vector<std::string>(), kIceUfrag1,
@@ -657,15 +667,15 @@ TEST_F(TransportControllerTest, TestSignalCandidatesGathered) {
"audio", local_desc, CA_OFFER, &err));
transport_controller_->MaybeStartGathering();
- channel->ice_transport()->SignalCandidateGathered(channel->ice_transport(),
- CreateCandidate(1));
+ transport->fake_ice_transport()->SignalCandidateGathered(
+ transport->fake_ice_transport(), CreateCandidate(1));
EXPECT_EQ_WAIT(1, candidates_signal_count_, kTimeout);
EXPECT_EQ(1U, candidates_["audio"].size());
}
TEST_F(TransportControllerTest, TestSignalingOccursOnSignalingThread) {
CreateTransportControllerWithNetworkThread();
- CreateChannelsAndCompleteConnectionOnNetworkThread();
+ CreateFakeDtlsTransportsAndCompleteConnectionOnNetworkThread();
// connecting --> connected --> completed
EXPECT_EQ_WAIT(kIceConnectionCompleted, connection_state_, kTimeout);
@@ -692,8 +702,8 @@ TEST_F(TransportControllerTest, TestSignalingOccursOnSignalingThread) {
// TODO(deadbeef): Remove this when these old versions of Chrome reach a low
// enough population.
TEST_F(TransportControllerTest, IceRoleRedeterminedOnIceRestartByDefault) {
- FakeDtlsTransport* channel = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel);
+ FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport);
std::string err;
// Do an initial offer answer, so that the next offer is an ICE restart.
transport_controller_->SetIceRole(ICEROLE_CONTROLLED);
@@ -707,7 +717,7 @@ TEST_F(TransportControllerTest, IceRoleRedeterminedOnIceRestartByDefault) {
CONNECTIONROLE_ACTPASS, nullptr);
EXPECT_TRUE(transport_controller_->SetLocalTransportDescription(
"audio", local_desc, CA_ANSWER, &err));
- EXPECT_EQ(ICEROLE_CONTROLLED, channel->GetIceRole());
+ EXPECT_EQ(ICEROLE_CONTROLLED, transport->fake_ice_transport()->GetIceRole());
// The endpoint that initiated an ICE restart should take the controlling
// role.
@@ -716,7 +726,7 @@ TEST_F(TransportControllerTest, IceRoleRedeterminedOnIceRestartByDefault) {
CONNECTIONROLE_ACTPASS, nullptr);
EXPECT_TRUE(transport_controller_->SetLocalTransportDescription(
"audio", ice_restart_desc, CA_OFFER, &err));
- EXPECT_EQ(ICEROLE_CONTROLLING, channel->GetIceRole());
+ EXPECT_EQ(ICEROLE_CONTROLLING, transport->fake_ice_transport()->GetIceRole());
}
// Test that if the TransportController was created with the
@@ -725,8 +735,8 @@ TEST_F(TransportControllerTest, IceRoleRedeterminedOnIceRestartByDefault) {
TEST_F(TransportControllerTest, IceRoleNotRedetermined) {
bool redetermine_role = false;
transport_controller_.reset(new TransportControllerForTest(redetermine_role));
- FakeDtlsTransport* channel = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel);
+ FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport);
std::string err;
// Do an initial offer answer, so that the next offer is an ICE restart.
transport_controller_->SetIceRole(ICEROLE_CONTROLLED);
@@ -740,7 +750,7 @@ TEST_F(TransportControllerTest, IceRoleNotRedetermined) {
CONNECTIONROLE_ACTPASS, nullptr);
EXPECT_TRUE(transport_controller_->SetLocalTransportDescription(
"audio", local_desc, CA_ANSWER, &err));
- EXPECT_EQ(ICEROLE_CONTROLLED, channel->GetIceRole());
+ EXPECT_EQ(ICEROLE_CONTROLLED, transport->fake_ice_transport()->GetIceRole());
// The endpoint that initiated an ICE restart should keep the existing role.
TransportDescription ice_restart_desc(std::vector<std::string>(), kIceUfrag3,
@@ -748,13 +758,13 @@ TEST_F(TransportControllerTest, IceRoleNotRedetermined) {
CONNECTIONROLE_ACTPASS, nullptr);
EXPECT_TRUE(transport_controller_->SetLocalTransportDescription(
"audio", ice_restart_desc, CA_OFFER, &err));
- EXPECT_EQ(ICEROLE_CONTROLLED, channel->GetIceRole());
+ EXPECT_EQ(ICEROLE_CONTROLLED, transport->fake_ice_transport()->GetIceRole());
}
-// Tests channel role is reversed after receiving ice-lite from remote.
+// Tests ICE role is reversed after receiving ice-lite from remote.
TEST_F(TransportControllerTest, TestSetRemoteIceLiteInOffer) {
- FakeDtlsTransport* channel = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel);
+ FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport);
std::string err;
transport_controller_->SetIceRole(ICEROLE_CONTROLLED);
@@ -767,39 +777,39 @@ TEST_F(TransportControllerTest, TestSetRemoteIceLiteInOffer) {
ASSERT_TRUE(transport_controller_->SetLocalTransportDescription(
"audio", local_desc, CA_ANSWER, nullptr));
- EXPECT_EQ(ICEROLE_CONTROLLING, channel->GetIceRole());
- EXPECT_EQ(ICEMODE_LITE, channel->remote_ice_mode());
+ EXPECT_EQ(ICEROLE_CONTROLLING, transport->fake_ice_transport()->GetIceRole());
+ EXPECT_EQ(ICEMODE_LITE, transport->fake_ice_transport()->remote_ice_mode());
}
// Tests ice-lite in remote answer.
TEST_F(TransportControllerTest, TestSetRemoteIceLiteInAnswer) {
- FakeDtlsTransport* channel = CreateChannel("audio", 1);
- ASSERT_NE(nullptr, channel);
+ FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
+ ASSERT_NE(nullptr, transport);
std::string err;
transport_controller_->SetIceRole(ICEROLE_CONTROLLING);
TransportDescription local_desc(kIceUfrag1, kIcePwd1);
ASSERT_TRUE(transport_controller_->SetLocalTransportDescription(
"audio", local_desc, CA_OFFER, nullptr));
- EXPECT_EQ(ICEROLE_CONTROLLING, channel->GetIceRole());
- // Channels will be created in ICEFULL_MODE.
- EXPECT_EQ(ICEMODE_FULL, channel->remote_ice_mode());
+ EXPECT_EQ(ICEROLE_CONTROLLING, transport->fake_ice_transport()->GetIceRole());
+ // Transports will be created in ICEFULL_MODE.
+ EXPECT_EQ(ICEMODE_FULL, transport->fake_ice_transport()->remote_ice_mode());
TransportDescription remote_desc(std::vector<std::string>(), kIceUfrag1,
kIcePwd1, ICEMODE_LITE, CONNECTIONROLE_NONE,
nullptr);
ASSERT_TRUE(transport_controller_->SetRemoteTransportDescription(
"audio", remote_desc, CA_ANSWER, nullptr));
- EXPECT_EQ(ICEROLE_CONTROLLING, channel->GetIceRole());
- // After receiving remote description with ICEMODE_LITE, channel should
+ EXPECT_EQ(ICEROLE_CONTROLLING, transport->fake_ice_transport()->GetIceRole());
+ // After receiving remote description with ICEMODE_LITE, transport should
// have mode set to ICEMODE_LITE.
- EXPECT_EQ(ICEMODE_LITE, channel->remote_ice_mode());
+ EXPECT_EQ(ICEMODE_LITE, transport->fake_ice_transport()->remote_ice_mode());
}
// Tests SetNeedsIceRestartFlag and NeedsIceRestart, setting the flag and then
// initiating an ICE restart for one of the transports.
TEST_F(TransportControllerTest, NeedsIceRestart) {
- CreateChannel("audio", 1);
- CreateChannel("video", 1);
+ CreateFakeDtlsTransport("audio", 1);
+ CreateFakeDtlsTransport("video", 1);
// Do initial offer/answer so there's something to restart.
TransportDescription local_desc(kIceUfrag1, kIcePwd1);
« no previous file with comments | « webrtc/p2p/base/jseptransport_unittest.cc ('k') | webrtc/pc/channel.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698