Chromium Code Reviews Chromium Code Reviews
Issue 2648233003:
Adding ability for BaseChannel to use PacketTransportInterface. (Closed)
| 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..65e85f4656e1f3d7f42046bdebd9b1e27108e6d6 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 "TransportTransportFactory" or something similar into |
|
pthatcher1
2017/01/25 00:02:19
Do you mean TransportControllerFactory?
Taylor Brandstetter
2017/01/25 00:31:43
Oops, that was from find/replacing "channel" with
|
| +// 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); |
