Remove the dependency of TransportChannel and TransportChannelImpl.

webrtc/p2p/base/dtlstransportchannel_unittest.cc

 /*
  *  Copyright 2011 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 79 matching lines @@
         new cricket::JsepTransport("dtls content name", certificate_));
     for (int i = 0; i < count; ++i) {
       cricket::FakeIceTransport* fake_ice_channel =
           new cricket::FakeIceTransport(transport_->mid(), i);
       fake_ice_channel->SetAsync(true);
       fake_ice_channel->SetAsyncDelay(async_delay_ms);
       // Hook the raw packets so that we can verify they are encrypted.
       fake_ice_channel->SignalReadPacket.connect(
           this, &DtlsTestClient::OnFakeTransportChannelReadPacket);
 
-      cricket::DtlsTransportChannelWrapper* channel =
-          new cricket::DtlsTransportChannelWrapper(fake_ice_channel);
-      channel->SetLocalCertificate(certificate_);
-      channel->SetIceRole(role);
-      channel->SetIceTiebreaker((role == cricket::ICEROLE_CONTROLLING) ? 1 : 2);
-      channel->SetSslMaxProtocolVersion(ssl_max_version_);
-      channel->SignalWritableState.connect(this,
-        &DtlsTestClient::OnTransportChannelWritableState);
-      channel->SignalReadPacket.connect(this,
-        &DtlsTestClient::OnTransportChannelReadPacket);
-      channel->SignalSentPacket.connect(
+      cricket::DtlsTransport* dtls =
+          new cricket::DtlsTransport(fake_ice_channel);
+      dtls->SetLocalCertificate(certificate_);
+      dtls->ice_transport()->SetIceRole(role);
+      dtls->ice_transport()->SetIceTiebreaker(
+          (role == cricket::ICEROLE_CONTROLLING) ? 1 : 2);
+      dtls->SetSslMaxProtocolVersion(ssl_max_version_);
+      dtls->SignalWritableState.connect(
+          this, &DtlsTestClient::OnTransportChannelWritableState);
+      dtls->SignalReadPacket.connect(
+          this, &DtlsTestClient::OnTransportChannelReadPacket);
+      dtls->SignalSentPacket.connect(
           this, &DtlsTestClient::OnTransportChannelSentPacket);
-      channels_.push_back(
-          std::unique_ptr<cricket::DtlsTransportChannelWrapper>(channel));
-      fake_channels_.push_back(
+      fake_dtls_transports_.push_back(
+          std::unique_ptr<cricket::DtlsTransport>(dtls));
+      fake_ice_transports_.push_back(
           std::unique_ptr<cricket::FakeIceTransport>(fake_ice_channel));
-      transport_->AddChannel(channel, i);
+      transport_->AddChannel(dtls, i);
     }
   }
 
   cricket::JsepTransport* transport() { return transport_.get(); }
 
-  cricket::FakeIceTransport* GetFakeChannel(int component) {
-    for (const auto& ch : fake_channels_) {
+  cricket::FakeIceTransport* GetFakeIceTransort(int component) {
+    for (const auto& ch : fake_ice_transports_) {
       if (ch->component() == component) {
         return ch.get();
       }
     }
     return nullptr;
   }
 
-  cricket::DtlsTransportChannelWrapper* GetDtlsChannel(int component) {
-    for (const auto& ch : channels_) {
-      if (ch->component() == component) {
-        return ch.get();
+  cricket::DtlsTransport* GetDtlsTransport(int component) {
+    for (const auto& dtls : fake_dtls_transports_) {
+      if (dtls->component() == component) {
+        return dtls.get();
       }
     }
     return nullptr;
   }
 
   // Offer DTLS if we have an identity; pass in a remote fingerprint only if
   // both sides support DTLS.
   void Negotiate(DtlsTestClient* peer, cricket::ContentAction action,
                  ConnectionRole local_role, ConnectionRole remote_role,
                  int flags) {
     Negotiate(certificate_, certificate_ ? peer->certificate_ : nullptr, action,
               local_role, remote_role, flags);
   }
 
   void MaybeSetSrtpCryptoSuites() {
     if (!use_dtls_srtp_) {
       return;
     }
     std::vector<int> ciphers;
     ciphers.push_back(rtc::SRTP_AES128_CM_SHA1_80);
     // SRTP ciphers will be set only in the beginning.
-    for (const auto& channel : channels_) {
-      EXPECT_TRUE(channel->SetSrtpCryptoSuites(ciphers));
+    for (const auto& dtls : fake_dtls_transports_) {
+      EXPECT_TRUE(dtls->SetSrtpCryptoSuites(ciphers));
     }
   }
 
   void SetLocalTransportDescription(
       const rtc::scoped_refptr<rtc::RTCCertificate>& cert,
       cricket::ContentAction action,
       ConnectionRole role,
       int flags) {
     // If |NF_EXPECT_FAILURE| is set, expect SRTD or SLTD to fail when
     // content action is CA_ANSWER.
@@ skipping 38 matching lines @@
       SetRemoteTransportDescription(remote_cert, cricket::CA_OFFER, remote_role,
                                     flags);
       // If remote if the offerer and has no DTLS support, answer will be
       // without any fingerprint.
       SetLocalTransportDescription(remote_cert ? local_cert : nullptr,
                                    cricket::CA_ANSWER, local_role, flags);
     }
   }
 
   bool Connect(DtlsTestClient* peer, bool asymmetric) {
-    for (auto& channel : fake_channels_) {
-      channel->SetDestination(peer->GetFakeChannel(channel->component()),
-                              asymmetric);
+    for (auto& ice : fake_ice_transports_) {
+      ice->SetDestination(peer->GetFakeIceTransort(ice->component()),
+                          asymmetric);
     }
     return true;
   }
 
-  bool all_channels_writable() const {
-    if (channels_.empty()) {
+  bool all_dtls_transports_writable() const {
+    if (fake_dtls_transports_.empty()) {
       return false;
     }
-    for (const auto& channel : channels_) {
-      if (!channel->writable()) {
+    for (const auto& dtls : fake_dtls_transports_) {
+      if (!dtls->writable()) {
         return false;
       }
     }
     return true;
   }
 
-  bool all_raw_channels_writable() const {
-    if (channels_.empty()) {
+  bool all_ice_transports_writable() const {
+    if (fake_dtls_transports_.empty()) {
       return false;
     }
-    for (const auto& channel : channels_) {
-      if (!channel->channel()->writable()) {
+    for (const auto& dtls : fake_dtls_transports_) {
+      if (!dtls->ice_transport()->writable()) {
         return false;
       }
     }
     return true;
   }
 
   int received_dtls_client_hellos() const {
     return received_dtls_client_hellos_;
   }
 
@@ skipping 12 matching lines @@
     if (role == rtc::SSL_CLIENT) {
       ASSERT_EQ(0, received_dtls_client_hellos_);
       ASSERT_GT(received_dtls_server_hellos_, 0);
     } else {
       ASSERT_GT(received_dtls_client_hellos_, 0);
       ASSERT_EQ(0, received_dtls_server_hellos_);
     }
   }
 
   void CheckSrtp(int expected_crypto_suite) {
-    for (const auto& channel : channels_) {
+    for (const auto& dtls : fake_dtls_transports_) {
       int crypto_suite;
 
-      bool rv = channel->GetSrtpCryptoSuite(&crypto_suite);
+      bool rv = dtls->GetSrtpCryptoSuite(&crypto_suite);
       if (negotiated_dtls() && expected_crypto_suite) {
         ASSERT_TRUE(rv);
 
         ASSERT_EQ(crypto_suite, expected_crypto_suite);
       } else {
         ASSERT_FALSE(rv);
       }
     }
   }
 
   void CheckSsl() {
-    for (const auto& channel : channels_) {
+    for (const auto& dtls : fake_dtls_transports_) {
       int cipher;
 
-      bool rv = channel->GetSslCipherSuite(&cipher);
+      bool rv = dtls->GetSslCipherSuite(&cipher);
       if (negotiated_dtls()) {
         ASSERT_TRUE(rv);
 
         EXPECT_TRUE(
             rtc::SSLStreamAdapter::IsAcceptableCipher(cipher, rtc::KT_DEFAULT));
       } else {
         ASSERT_FALSE(rv);
       }
     }
   }
 
-  void SendPackets(size_t channel, size_t size, size_t count, bool srtp) {
-    RTC_CHECK(channel < channels_.size());
+  void SendPackets(size_t transport, size_t size, size_t count, bool srtp) {
+    RTC_CHECK(transport < fake_dtls_transports_.size());
     std::unique_ptr<char[]> packet(new char[size]);
     size_t sent = 0;
     do {
       // Fill the packet with a known value and a sequence number to check
       // against, and make sure that it doesn't look like DTLS.
       memset(packet.get(), sent & 0xff, size);
       packet[0] = (srtp) ? 0x80 : 0x00;
       rtc::SetBE32(packet.get() + kPacketNumOffset,
                    static_cast<uint32_t>(sent));
 
       // Only set the bypass flag if we've activated DTLS.
       int flags = (certificate_ && srtp) ? cricket::PF_SRTP_BYPASS : 0;
       rtc::PacketOptions packet_options;
       packet_options.packet_id = kFakePacketId;
-      int rv = channels_[channel]->SendPacket(
+      int rv = fake_dtls_transports_[transport]->SendPacket(
           packet.get(), size, packet_options, flags);
       ASSERT_GT(rv, 0);
       ASSERT_EQ(size, static_cast<size_t>(rv));
       ++sent;
     } while (sent < count);
   }
 
-  int SendInvalidSrtpPacket(size_t channel, size_t size) {
-    RTC_CHECK(channel < channels_.size());
+  int SendInvalidSrtpPacket(size_t transport, size_t size) {
+    RTC_CHECK(transport < fake_dtls_transports_.size());
     std::unique_ptr<char[]> packet(new char[size]);
     // Fill the packet with 0 to form an invalid SRTP packet.
     memset(packet.get(), 0, size);
 
     rtc::PacketOptions packet_options;
-    return channels_[channel]->SendPacket(
+    return fake_dtls_transports_[transport]->SendPacket(
         packet.get(), size, packet_options, cricket::PF_SRTP_BYPASS);
   }
 
-  void ExpectPackets(size_t channel, size_t size) {
+  void ExpectPackets(size_t transport, size_t size) {
     packet_size_ = size;
     received_.clear();
   }
 
   size_t NumPacketsReceived() {
     return received_.size();
   }
 
   bool VerifyPacket(const char* data, size_t size, uint32_t* out_num) {
     if (size != packet_size_ ||
@@ skipping 79 matching lines @@
         ASSERT_TRUE(VerifyEncryptedPacket(data, size));
       } else if (IsRtpLeadByte(data[0])) {
         ASSERT_TRUE(VerifyPacket(data, size, NULL));
       }
     }
   }
 
  private:
   std::string name_;
   rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
-  std::vector<std::unique_ptr<cricket::FakeIceTransport>> fake_channels_;
-  std::vector<std::unique_ptr<cricket::DtlsTransportChannelWrapper>> channels_;
+  std::vector<std::unique_ptr<cricket::FakeIceTransport>> fake_ice_transports_;
+  std::vector<std::unique_ptr<cricket::DtlsTransport>> fake_dtls_transports_;
   std::unique_ptr<cricket::JsepTransport> transport_;
   size_t packet_size_ = 0u;
   std::set<int> received_;
   bool use_dtls_srtp_ = false;
   rtc::SSLProtocolVersion ssl_max_version_ = rtc::SSL_PROTOCOL_DTLS_12;
   int received_dtls_client_hellos_ = 0;
   int received_dtls_server_hellos_ = 0;
   rtc::SentPacket sent_packet_;
 };
 
@@ skipping 70 matching lines @@
           client2_.certificate(), cricket::CA_ANSWER, client2_role, 0);
       rv = client1_.Connect(&client2_, false);
       client1_.SetRemoteTransportDescription(
           client2_.certificate(), cricket::CA_ANSWER, client2_role, 0);
     }
 
     EXPECT_TRUE(rv);
     if (!rv)
       return false;
 
-    EXPECT_TRUE_SIMULATED_WAIT(
-        client1_.all_channels_writable() && client2_.all_channels_writable(),
-        kTimeout, fake_clock_);
-    if (!client1_.all_channels_writable() || !client2_.all_channels_writable())
+    EXPECT_TRUE_SIMULATED_WAIT(client1_.all_dtls_transports_writable() &&
+                                   client2_.all_dtls_transports_writable(),
+                               kTimeout, fake_clock_);
+    if (!client1_.all_dtls_transports_writable() ||
+        !client2_.all_dtls_transports_writable())
       return false;
 
     // Check that we used the right roles.
     if (use_dtls_) {
       rtc::SSLRole client1_ssl_role =
           (client1_role == cricket::CONNECTIONROLE_ACTIVE ||
            (client2_role == cricket::CONNECTIONROLE_PASSIVE &&
             client1_role == cricket::CONNECTIONROLE_ACTPASS)) ?
               rtc::SSL_CLIENT : rtc::SSL_SERVER;
 
@@ skipping 65 matching lines @@
       client2_.Negotiate(&client1_, cricket::CA_ANSWER,
                          client2_role, client1_role, flags);
     } else {
       client2_.Negotiate(&client1_, cricket::CA_OFFER,
                          client2_role, client1_role, flags);
       client1_.Negotiate(&client2_, cricket::CA_ANSWER,
                          client1_role, client2_role, flags);
     }
   }
 
-  void TestTransfer(size_t channel, size_t size, size_t count, bool srtp) {
+  void TestTransfer(size_t transport, size_t size, size_t count, bool srtp) {
     LOG(LS_INFO) << "Expect packets, size=" << size;
-    client2_.ExpectPackets(channel, size);
-    client1_.SendPackets(channel, size, count, srtp);
+    client2_.ExpectPackets(transport, size);
+    client1_.SendPackets(transport, size, count, srtp);
     EXPECT_EQ_SIMULATED_WAIT(count, client2_.NumPacketsReceived(), kTimeout,
                              fake_clock_);
   }
 
  protected:
   rtc::ScopedFakeClock fake_clock_;
   DtlsTestClient client1_;
   DtlsTestClient client2_;
   int channel_ct_;
   bool use_dtls_;
   bool use_dtls_srtp_;
   rtc::SSLProtocolVersion ssl_expected_version_;
 };
 
 class DtlsTransportChannelTest : public DtlsTransportChannelTestBase,
                                  public ::testing::Test {};
 
 // Test that transport negotiation of ICE, no DTLS works properly.
 TEST_F(DtlsTransportChannelTest, TestChannelSetupIce) {
   Negotiate();
-  cricket::FakeIceTransport* channel1 = client1_.GetFakeChannel(0);
-  cricket::FakeIceTransport* channel2 = client2_.GetFakeChannel(0);
+  cricket::FakeIceTransport* channel1 = client1_.GetFakeIceTransort(0);
+  cricket::FakeIceTransport* channel2 = client2_.GetFakeIceTransort(0);
   ASSERT_TRUE(channel1 != NULL);
   ASSERT_TRUE(channel2 != NULL);
   EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel1->GetIceRole());
   EXPECT_EQ(1U, channel1->IceTiebreaker());
   EXPECT_EQ(kIceUfrag1, channel1->ice_ufrag());
   EXPECT_EQ(kIcePwd1, channel1->ice_pwd());
   EXPECT_EQ(cricket::ICEROLE_CONTROLLED, channel2->GetIceRole());
   EXPECT_EQ(2U, channel2->IceTiebreaker());
 }
 
@@ skipping 258 matching lines @@
   MAYBE_SKIP_TEST(HaveDtlsSrtp);
   SetChannelCount(2);
   PrepareDtls(true, true, rtc::KT_DEFAULT);
   PrepareDtlsSrtp(true, true);
   Negotiate();
 
   Renegotiate(&client1_, cricket::CONNECTIONROLE_ACTPASS,
               cricket::CONNECTIONROLE_ACTIVE, NF_REOFFER);
   bool rv = client1_.Connect(&client2_, false);
   EXPECT_TRUE(rv);
-  EXPECT_TRUE_SIMULATED_WAIT(
-      client1_.all_channels_writable() && client2_.all_channels_writable(),
-      kTimeout, fake_clock_);
+  EXPECT_TRUE_SIMULATED_WAIT(client1_.all_dtls_transports_writable() &&
+                                 client2_.all_dtls_transports_writable(),
+                             kTimeout, fake_clock_);
 
   TestTransfer(0, 1000, 100, true);
   TestTransfer(1, 1000, 100, true);
 }
 
 // Test Certificates state after negotiation but before connection.
 TEST_F(DtlsTransportChannelTest, TestCertificatesBeforeConnect) {
   MAYBE_SKIP_TEST(HaveDtls);
   PrepareDtls(true, true, rtc::KT_DEFAULT);
   Negotiate();
 
   rtc::scoped_refptr<rtc::RTCCertificate> certificate1;
   rtc::scoped_refptr<rtc::RTCCertificate> certificate2;
   std::unique_ptr<rtc::SSLCertificate> remote_cert1;
   std::unique_ptr<rtc::SSLCertificate> remote_cert2;
 
   // After negotiation, each side has a distinct local certificate, but still no
   // remote certificate, because connection has not yet occurred.
   ASSERT_TRUE(client1_.transport()->GetLocalCertificate(&certificate1));
   ASSERT_TRUE(client2_.transport()->GetLocalCertificate(&certificate2));
   ASSERT_NE(certificate1->ssl_certificate().ToPEMString(),
             certificate2->ssl_certificate().ToPEMString());
-  ASSERT_FALSE(client1_.GetDtlsChannel(0)->GetRemoteSSLCertificate());
-  ASSERT_FALSE(client2_.GetDtlsChannel(0)->GetRemoteSSLCertificate());
+  ASSERT_FALSE(client1_.GetDtlsTransport(0)->GetRemoteSSLCertificate());
+  ASSERT_FALSE(client2_.GetDtlsTransport(0)->GetRemoteSSLCertificate());
 }
 
 // Test Certificates state after connection.
 TEST_F(DtlsTransportChannelTest, TestCertificatesAfterConnect) {
   MAYBE_SKIP_TEST(HaveDtls);
   PrepareDtls(true, true, rtc::KT_DEFAULT);
   ASSERT_TRUE(Connect());
 
   rtc::scoped_refptr<rtc::RTCCertificate> certificate1;
   rtc::scoped_refptr<rtc::RTCCertificate> certificate2;
 
   // After connection, each side has a distinct local certificate.
   ASSERT_TRUE(client1_.transport()->GetLocalCertificate(&certificate1));
   ASSERT_TRUE(client2_.transport()->GetLocalCertificate(&certificate2));
   ASSERT_NE(certificate1->ssl_certificate().ToPEMString(),
             certificate2->ssl_certificate().ToPEMString());
 
   // Each side's remote certificate is the other side's local certificate.
   std::unique_ptr<rtc::SSLCertificate> remote_cert1 =
-      client1_.GetDtlsChannel(0)->GetRemoteSSLCertificate();
+      client1_.GetDtlsTransport(0)->GetRemoteSSLCertificate();
   ASSERT_TRUE(remote_cert1);
   ASSERT_EQ(remote_cert1->ToPEMString(),
             certificate2->ssl_certificate().ToPEMString());
   std::unique_ptr<rtc::SSLCertificate> remote_cert2 =
-      client2_.GetDtlsChannel(0)->GetRemoteSSLCertificate();
+      client2_.GetDtlsTransport(0)->GetRemoteSSLCertificate();
   ASSERT_TRUE(remote_cert2);
   ASSERT_EQ(remote_cert2->ToPEMString(),
             certificate1->ssl_certificate().ToPEMString());
 }
 
 // Test that packets are retransmitted according to the expected schedule.
 // Each time a timeout occurs, the retransmission timer should be doubled up to
 // 60 seconds. The timer defaults to 1 second, but for WebRTC we should be
 // initializing it to 50ms.
 TEST_F(DtlsTransportChannelTest, TestRetransmissionSchedule) {
   MAYBE_SKIP_TEST(HaveDtls);
   // We can only change the retransmission schedule with a recently-added
   // BoringSSL API. Skip the test if not built with BoringSSL.
   MAYBE_SKIP_TEST(IsBoringSsl);
 
   PrepareDtls(true, true, rtc::KT_DEFAULT);
   // Exchange transport descriptions.
   Negotiate(cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_ACTIVE);
 
   // Make client2_ writable, but not client1_.
   // This means client1_ will send DTLS client hellos but get no response.
   EXPECT_TRUE(client2_.Connect(&client1_, true));
-  EXPECT_TRUE_SIMULATED_WAIT(client2_.all_raw_channels_writable(), kTimeout,
+  EXPECT_TRUE_SIMULATED_WAIT(client2_.all_ice_transports_writable(), kTimeout,
                              fake_clock_);
 
   // Wait for the first client hello to be sent.
   EXPECT_EQ_WAIT(1, client1_.received_dtls_client_hellos(), kTimeout);
-  EXPECT_FALSE(client1_.all_raw_channels_writable());
+  EXPECT_FALSE(client1_.all_ice_transports_writable());
 
   static int timeout_schedule_ms[] = {50,   100,  200,   400,   800,   1600,
                                       3200, 6400, 12800, 25600, 51200, 60000};
 
   int expected_hellos = 1;
   for (size_t i = 0;
        i < (sizeof(timeout_schedule_ms) / sizeof(timeout_schedule_ms[0]));
        ++i) {
     // For each expected retransmission time, advance the fake clock a
     // millisecond before the expected time and verify that no unexpected
@@ skipping 84 matching lines @@
             ++(remote_desc.identity_fingerprint->digest[0]);
             // Even if certificate verification fails inside this method,
             // it should return true as long as the fingerprint was formatted
             // correctly.
             EXPECT_TRUE(client1_.transport()->SetRemoteTransportDescription(
                 remote_desc, cricket::CA_ANSWER, nullptr));
           }
           break;
         case CALLER_WRITABLE:
           EXPECT_TRUE(client1_.Connect(&client2_, true));
-          EXPECT_TRUE_SIMULATED_WAIT(client1_.all_raw_channels_writable(),
+          EXPECT_TRUE_SIMULATED_WAIT(client1_.all_ice_transports_writable(),
                                      kTimeout, fake_clock_);
           break;
         case CALLER_RECEIVES_CLIENTHELLO:
           // Sanity check that a ClientHello hasn't already been received.
           EXPECT_EQ(0, client1_.received_dtls_client_hellos());
           // Making client2_ writable will cause it to send the ClientHello.
           EXPECT_TRUE(client2_.Connect(&client1_, true));
-          EXPECT_TRUE_SIMULATED_WAIT(client2_.all_raw_channels_writable(),
+          EXPECT_TRUE_SIMULATED_WAIT(client2_.all_ice_transports_writable(),
                                      kTimeout, fake_clock_);
           EXPECT_EQ_SIMULATED_WAIT(1, client1_.received_dtls_client_hellos(),
                                    kTimeout, fake_clock_);
           break;
         case HANDSHAKE_FINISHES:
           // Sanity check that the handshake hasn't already finished.
-          EXPECT_FALSE(client1_.GetDtlsChannel(0)->IsDtlsConnected() ||
-                       client1_.GetDtlsChannel(0)->dtls_state() ==
+          EXPECT_FALSE(client1_.GetDtlsTransport(0)->IsDtlsConnected() ||
+                       client1_.GetDtlsTransport(0)->dtls_state() ==
                            cricket::DTLS_TRANSPORT_FAILED);
           EXPECT_TRUE_SIMULATED_WAIT(
-              client1_.GetDtlsChannel(0)->IsDtlsConnected() ||
-                  client1_.GetDtlsChannel(0)->dtls_state() ==
+              client1_.GetDtlsTransport(0)->IsDtlsConnected() ||
+                  client1_.GetDtlsTransport(0)->dtls_state() ==
                       cricket::DTLS_TRANSPORT_FAILED,
               kTimeout, fake_clock_);
           break;
       }
     }
 
     cricket::DtlsTransportState expected_final_state =
         valid_fingerprint ? cricket::DTLS_TRANSPORT_CONNECTED
                           : cricket::DTLS_TRANSPORT_FAILED;
     EXPECT_EQ_SIMULATED_WAIT(expected_final_state,
-                             client1_.GetDtlsChannel(0)->dtls_state(), kTimeout,
-                             fake_clock_);
+                             client1_.GetDtlsTransport(0)->dtls_state(),
+                             kTimeout, fake_clock_);
     EXPECT_EQ_SIMULATED_WAIT(expected_final_state,
-                             client2_.GetDtlsChannel(0)->dtls_state(), kTimeout,
-                             fake_clock_);
+                             client2_.GetDtlsTransport(0)->dtls_state(),
+                             kTimeout, fake_clock_);
 
     // Channel should be writable iff there was a valid fingerprint.
-    EXPECT_EQ(valid_fingerprint, client1_.GetDtlsChannel(0)->writable());
-    EXPECT_EQ(valid_fingerprint, client2_.GetDtlsChannel(0)->writable());
+    EXPECT_EQ(valid_fingerprint, client1_.GetDtlsTransport(0)->writable());
+    EXPECT_EQ(valid_fingerprint, client2_.GetDtlsTransport(0)->writable());
 
     // Check that no hello needed to be retransmitted.
     EXPECT_EQ(1, client1_.received_dtls_client_hellos());
     EXPECT_EQ(1, client2_.received_dtls_server_hellos());
 
     if (valid_fingerprint) {
       TestTransfer(0, 1000, 100, false);
     }
   }
 };
@@ skipping 27 matching lines @@
             std::vector<DtlsTransportEvent>{
                 CALLER_RECEIVES_CLIENTHELLO, CALLER_RECEIVES_FINGERPRINT,
                 CALLER_WRITABLE, HANDSHAKE_FINISHES},
             std::vector<DtlsTransportEvent>{
                 CALLER_RECEIVES_CLIENTHELLO, CALLER_WRITABLE,
                 CALLER_RECEIVES_FINGERPRINT, HANDSHAKE_FINISHES},
             std::vector<DtlsTransportEvent>{CALLER_RECEIVES_CLIENTHELLO,
                                             CALLER_WRITABLE, HANDSHAKE_FINISHES,
                                             CALLER_RECEIVES_FINGERPRINT}),
         ::testing::Bool()));