Adding ability for BaseChannel to use PacketTransportInterface.

webrtc/p2p/base/transportcontroller_unittest.cc

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 16 matching lines @@
 static const char kIceUfrag1[] = "TESTICEUFRAG0001";
 static const char kIcePwd1[] = "TESTICEPWD00000000000001";
 static const char kIceUfrag2[] = "TESTICEUFRAG0002";
 static const char kIcePwd2[] = "TESTICEPWD00000000000002";
 static const char kIceUfrag3[] = "TESTICEUFRAG0003";
 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,
                                 public sigslot::has_slots<> {
  public:
   TransportControllerTest()
       : transport_controller_(new TransportControllerForTest()),
         signaling_thread_(rtc::Thread::Current()) {
     ConnectTransportControllerSignals();
   }
@@ skipping 12 matching lines @@
     transport_controller_->SignalConnectionState.connect(
         this, &TransportControllerTest::OnConnectionState);
     transport_controller_->SignalReceiving.connect(
         this, &TransportControllerTest::OnReceiving);
     transport_controller_->SignalGatheringState.connect(
         this, &TransportControllerTest::OnGatheringState);
     transport_controller_->SignalCandidatesGathered.connect(
         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);
   }
 
   Candidate CreateCandidate(int component) {
     Candidate c;
     c.set_address(rtc::SocketAddress("192.168.1.1", 8000));
     c.set_component(1);
     c.set_protocol(UDP_PROTOCOL_NAME);
     c.set_priority(1);
     return c;
   }
 
   // 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,
                                     CONNECTIONROLE_ACTPASS, nullptr);
     std::string err;
     transport_controller_->SetLocalTransportDescription("audio", local_desc,
                                                         CA_OFFER, &err);
     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(
       int receiving_timeout,
       ContinualGatheringPolicy continual_gathering_policy) {
     IceConfig config;
     config.receiving_timeout = receiving_timeout;
     config.continual_gathering_policy = continual_gathering_policy;
     return config;
   }
@@ skipping 47 matching lines @@
   int receiving_signal_count_ = 0;
   int gathering_state_signal_count_ = 0;
   int candidates_signal_count_ = 0;
 
   // Used to make sure signals only come on signaling thread.
   rtc::Thread* const signaling_thread_ = nullptr;
   bool signaled_on_non_signaling_thread_ = false;
 };
 
 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(
       rtc::SSL_PROTOCOL_DTLS_10));
 }
 
 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));
   EXPECT_EQ(rtc::SSL_CLIENT, role);
 }
 
 TEST_F(TransportControllerTest, TestSetAndGetLocalCertificate) {
   rtc::scoped_refptr<rtc::RTCCertificate> certificate1 =
       rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
           rtc::SSLIdentity::Generate("session1", rtc::KT_DEFAULT)));
   rtc::scoped_refptr<rtc::RTCCertificate> certificate2 =
       rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
           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(
       "audio", &returned_certificate));
   EXPECT_EQ(certificate1->identity()->certificate().ToPEMString(),
             returned_certificate->identity()->certificate().ToPEMString());
 
   // Should fail if called for a nonexistant transport.
   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(),
             returned_certificate->identity()->certificate().ToPEMString());
 
   // Shouldn't be able to change the identity once set.
   EXPECT_FALSE(transport_controller_->SetLocalCertificate(certificate2));
 }
 
 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);
   EXPECT_EQ(fake_certificate.ToPEMString(),
             returned_certificate->ToPEMString());
 
   // Should fail if called for a nonexistant transport.
   EXPECT_FALSE(transport_controller_->GetRemoteSSLCertificate("video"));
 }
 
 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();
   EXPECT_EQ_WAIT(kIceGatheringGathering, gathering_state_, kTimeout);
   EXPECT_EQ(1, gathering_state_signal_count_);
 }
 
 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"));
 
   std::string err;
   TransportDescription remote_desc(std::vector<std::string>(), kIceUfrag1,
                                    kIcePwd1, ICEMODE_FULL,
                                    CONNECTIONROLE_ACTPASS, nullptr);
   EXPECT_TRUE(transport_controller_->SetRemoteTransportDescription(
       "audio", remote_desc, CA_OFFER, &err));
   EXPECT_FALSE(transport_controller_->ReadyForRemoteCandidates("audio"));
 
   TransportDescription local_desc(std::vector<std::string>(), kIceUfrag2,
                                   kIcePwd2, ICEMODE_FULL,
                                   CONNECTIONROLE_ACTPASS, nullptr);
   EXPECT_TRUE(transport_controller_->SetLocalTransportDescription(
       "audio", local_desc, CA_ANSWER, &err));
   EXPECT_TRUE(transport_controller_->ReadyForRemoteCandidates("audio"));
 }
 
 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));
   EXPECT_EQ("audio", stats.transport_name);
   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);
+  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 channel connect, and another fail, to ensure that
-  // the first channel connecting didn't trigger a "connected" state signal.
+  // 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_);
 }
 
 // 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);
+  FakeDtlsTransport* transport1 = CreateFakeDtlsTransport("audio", 1);
+  ASSERT_NE(nullptr, transport1);
+  FakeDtlsTransport* transport2 = CreateFakeDtlsTransport("video", 1);
+  ASSERT_NE(nullptr, transport2);
 
-  channel1->SetCandidatesGatheringComplete();
-  channel1->SetConnectionCount(2);
-  channel1->SetWritable(true);
-  channel2->SetCandidatesGatheringComplete();
-  channel2->SetConnectionCount(2);
-  channel2->SetWritable(true);
+  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_);
 }
 
 // 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);
+  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);
 
-  channel3->ice_transport()->MaybeStartGathering();
+  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_);
 }
 
 // Test that when the last transport that hasn't finished connecting and/or
 // gathering is destroyed, the aggregate state jumps to "completed". This can
 // happen if, for example, we have an audio and video transport, the audio
 // transport completes, then we start bundling video on the audio transport.
 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);
   EXPECT_EQ(2, gathering_state_signal_count_);
 }
 
 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,
                                   kIcePwd1, ICEMODE_FULL,
                                   CONNECTIONROLE_ACTPASS, nullptr);
   std::string err;
   EXPECT_TRUE(transport_controller_->SetLocalTransportDescription(
       "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);
   EXPECT_EQ(2, connection_state_signal_count_);
 
   EXPECT_TRUE_WAIT(receiving_, kTimeout);
   EXPECT_EQ(1, receiving_signal_count_);
 
   // new --> gathering --> complete
   EXPECT_EQ_WAIT(kIceGatheringComplete, gathering_state_, kTimeout);
   EXPECT_EQ(2, gathering_state_signal_count_);
 
   EXPECT_EQ_WAIT(1U, candidates_["audio"].size(), kTimeout);
   EXPECT_EQ_WAIT(1U, candidates_["video"].size(), kTimeout);
   EXPECT_EQ(2, candidates_signal_count_);
 
   EXPECT_TRUE(!signaled_on_non_signaling_thread_);
 }
 
 // Older versions of Chrome expect the ICE role to be re-determined when an
 // ICE restart occurs, and also don't perform conflict resolution correctly,
 // so for now we can't safely stop doing this.
 // See: https://bugs.chromium.org/p/chromium/issues/detail?id=628676
 // 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);
   TransportDescription remote_desc(std::vector<std::string>(), kIceUfrag1,
                                    kIcePwd1, ICEMODE_FULL,
                                    CONNECTIONROLE_ACTPASS, nullptr);
   EXPECT_TRUE(transport_controller_->SetRemoteTransportDescription(
       "audio", remote_desc, CA_OFFER, &err));
   TransportDescription local_desc(std::vector<std::string>(), kIceUfrag2,
                                   kIcePwd2, ICEMODE_FULL,
                                   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.
   TransportDescription ice_restart_desc(std::vector<std::string>(), kIceUfrag3,
                                         kIcePwd3, ICEMODE_FULL,
                                         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
 // |redetermine_role_on_ice_restart| parameter set to false, the role is *not*
 // redetermined on an ICE restart.
 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);
   TransportDescription remote_desc(std::vector<std::string>(), kIceUfrag1,
                                    kIcePwd1, ICEMODE_FULL,
                                    CONNECTIONROLE_ACTPASS, nullptr);
   EXPECT_TRUE(transport_controller_->SetRemoteTransportDescription(
       "audio", remote_desc, CA_OFFER, &err));
   TransportDescription local_desc(std::vector<std::string>(), kIceUfrag2,
                                   kIcePwd2, ICEMODE_FULL,
                                   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,
                                         kIcePwd3, ICEMODE_FULL,
                                         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);
   TransportDescription remote_desc(std::vector<std::string>(), kIceUfrag1,
                                    kIcePwd1, ICEMODE_LITE,
                                    CONNECTIONROLE_ACTPASS, nullptr);
   EXPECT_TRUE(transport_controller_->SetRemoteTransportDescription(
       "audio", remote_desc, CA_OFFER, &err));
   TransportDescription local_desc(kIceUfrag1, kIcePwd1);
   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);
   TransportDescription remote_desc(kIceUfrag1, kIcePwd1);
   ASSERT_TRUE(transport_controller_->SetLocalTransportDescription(
       "audio", local_desc, CA_OFFER, nullptr));
   ASSERT_TRUE(transport_controller_->SetLocalTransportDescription(
       "video", local_desc, CA_OFFER, nullptr));
   ASSERT_TRUE(transport_controller_->SetRemoteTransportDescription(
       "audio", remote_desc, CA_ANSWER, nullptr));
@@ skipping 17 matching lines @@
   ASSERT_TRUE(transport_controller_->SetLocalTransportDescription(
       "audio", ice_restart_local_desc, CA_OFFER, nullptr));
   ASSERT_TRUE(transport_controller_->SetLocalTransportDescription(
       "video", local_desc, CA_OFFER, nullptr));
   // NeedsIceRestart should still be true for video.
   EXPECT_FALSE(transport_controller_->NeedsIceRestart("audio"));
   EXPECT_TRUE(transport_controller_->NeedsIceRestart("video"));
 }
 
 }  // namespace cricket {