Revert of make the DtlsTransportWrapper inherit form DtlsTransportInternal

webrtc/p2p/base/dtlstransportchannel_unittest.cc

Index: webrtc/p2p/base/dtlstransportchannel_unittest.cc
diff --git a/webrtc/p2p/base/dtlstransportchannel_unittest.cc b/webrtc/p2p/base/dtlstransportchannel_unittest.cc
index 2fc95d4e3b307865c5166b898e6cc7759edd56b2..4eba26d241db00574070fda57bd12c53c32f90ea 100644
--- a/webrtc/p2p/base/dtlstransportchannel_unittest.cc
+++ b/webrtc/p2p/base/dtlstransportchannel_unittest.cc
@@ -97,31 +97,30 @@
       fake_ice_channel->SignalReadPacket.connect(
           this, &DtlsTestClient::OnFakeTransportChannelReadPacket);
 
-      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(
+      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(
           this, &DtlsTestClient::OnTransportChannelSentPacket);
-      fake_dtls_transports_.push_back(
-          std::unique_ptr<cricket::DtlsTransport>(dtls));
-      fake_ice_transports_.push_back(
+      channels_.push_back(
+          std::unique_ptr<cricket::DtlsTransportChannelWrapper>(channel));
+      fake_channels_.push_back(
           std::unique_ptr<cricket::FakeIceTransport>(fake_ice_channel));
-      transport_->AddChannel(dtls, i);
+      transport_->AddChannel(channel, i);
     }
   }
 
   cricket::JsepTransport* transport() { return transport_.get(); }
 
-  cricket::FakeIceTransport* GetFakeIceTransort(int component) {
-    for (const auto& ch : fake_ice_transports_) {
+  cricket::FakeIceTransport* GetFakeChannel(int component) {
+    for (const auto& ch : fake_channels_) {
       if (ch->component() == component) {
         return ch.get();
       }
@@ -129,10 +128,10 @@
     return nullptr;
   }
 
-  cricket::DtlsTransport* GetDtlsTransport(int component) {
-    for (const auto& dtls : fake_dtls_transports_) {
-      if (dtls->component() == component) {
-        return dtls.get();
+  cricket::DtlsTransportChannelWrapper* GetDtlsChannel(int component) {
+    for (const auto& ch : channels_) {
+      if (ch->component() == component) {
+        return ch.get();
       }
     }
     return nullptr;
@@ -154,8 +153,8 @@
     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& dtls : fake_dtls_transports_) {
-      EXPECT_TRUE(dtls->SetSrtpCryptoSuites(ciphers));
+    for (const auto& channel : channels_) {
+      EXPECT_TRUE(channel->SetSrtpCryptoSuites(ciphers));
     }
   }
 
@@ -214,31 +213,31 @@
   }
 
   bool Connect(DtlsTestClient* peer, bool asymmetric) {
-    for (auto& ice : fake_ice_transports_) {
-      ice->SetDestination(peer->GetFakeIceTransort(ice->component()),
-                          asymmetric);
+    for (auto& channel : fake_channels_) {
+      channel->SetDestination(peer->GetFakeChannel(channel->component()),
+                              asymmetric);
     }
     return true;
   }
 
-  bool all_dtls_transports_writable() const {
-    if (fake_dtls_transports_.empty()) {
+  bool all_channels_writable() const {
+    if (channels_.empty()) {
       return false;
     }
-    for (const auto& dtls : fake_dtls_transports_) {
-      if (!dtls->writable()) {
+    for (const auto& channel : channels_) {
+      if (!channel->writable()) {
         return false;
       }
     }
     return true;
   }
 
-  bool all_ice_transports_writable() const {
-    if (fake_dtls_transports_.empty()) {
+  bool all_raw_channels_writable() const {
+    if (channels_.empty()) {
       return false;
     }
-    for (const auto& dtls : fake_dtls_transports_) {
-      if (!dtls->ice_transport()->writable()) {
+    for (const auto& channel : channels_) {
+      if (!channel->channel()->writable()) {
         return false;
       }
     }
@@ -271,10 +270,10 @@
   }
 
   void CheckSrtp(int expected_crypto_suite) {
-    for (const auto& dtls : fake_dtls_transports_) {
+    for (const auto& channel : channels_) {
       int crypto_suite;
 
-      bool rv = dtls->GetSrtpCryptoSuite(&crypto_suite);
+      bool rv = channel->GetSrtpCryptoSuite(&crypto_suite);
       if (negotiated_dtls() && expected_crypto_suite) {
         ASSERT_TRUE(rv);
 
@@ -286,10 +285,10 @@
   }
 
   void CheckSsl() {
-    for (const auto& dtls : fake_dtls_transports_) {
+    for (const auto& channel : channels_) {
       int cipher;
 
-      bool rv = dtls->GetSslCipherSuite(&cipher);
+      bool rv = channel->GetSslCipherSuite(&cipher);
       if (negotiated_dtls()) {
         ASSERT_TRUE(rv);
 
@@ -301,8 +300,8 @@
     }
   }
 
-  void SendPackets(size_t transport, size_t size, size_t count, bool srtp) {
-    RTC_CHECK(transport < fake_dtls_transports_.size());
+  void SendPackets(size_t channel, size_t size, size_t count, bool srtp) {
+    RTC_CHECK(channel < channels_.size());
     std::unique_ptr<char[]> packet(new char[size]);
     size_t sent = 0;
     do {
@@ -317,7 +316,7 @@
       int flags = (certificate_ && srtp) ? cricket::PF_SRTP_BYPASS : 0;
       rtc::PacketOptions packet_options;
       packet_options.packet_id = kFakePacketId;
-      int rv = fake_dtls_transports_[transport]->SendPacket(
+      int rv = channels_[channel]->SendPacket(
           packet.get(), size, packet_options, flags);
       ASSERT_GT(rv, 0);
       ASSERT_EQ(size, static_cast<size_t>(rv));
@@ -325,18 +324,18 @@
     } while (sent < count);
   }
 
-  int SendInvalidSrtpPacket(size_t transport, size_t size) {
-    RTC_CHECK(transport < fake_dtls_transports_.size());
+  int SendInvalidSrtpPacket(size_t channel, size_t size) {
+    RTC_CHECK(channel < channels_.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 fake_dtls_transports_[transport]->SendPacket(
+    return channels_[channel]->SendPacket(
         packet.get(), size, packet_options, cricket::PF_SRTP_BYPASS);
   }
 
-  void ExpectPackets(size_t transport, size_t size) {
+  void ExpectPackets(size_t channel, size_t size) {
     packet_size_ = size;
     received_.clear();
   }
@@ -436,8 +435,8 @@
  private:
   std::string name_;
   rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
-  std::vector<std::unique_ptr<cricket::FakeIceTransport>> fake_ice_transports_;
-  std::vector<std::unique_ptr<cricket::DtlsTransport>> fake_dtls_transports_;
+  std::vector<std::unique_ptr<cricket::FakeIceTransport>> fake_channels_;
+  std::vector<std::unique_ptr<cricket::DtlsTransportChannelWrapper>> channels_;
   std::unique_ptr<cricket::JsepTransport> transport_;
   size_t packet_size_ = 0u;
   std::set<int> received_;
@@ -528,11 +527,10 @@
     if (!rv)
       return false;
 
-    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())
+    EXPECT_TRUE_SIMULATED_WAIT(
+        client1_.all_channels_writable() && client2_.all_channels_writable(),
+        kTimeout, fake_clock_);
+    if (!client1_.all_channels_writable() || !client2_.all_channels_writable())
       return false;
 
     // Check that we used the right roles.
@@ -618,10 +616,10 @@
     }
   }
 
-  void TestTransfer(size_t transport, size_t size, size_t count, bool srtp) {
+  void TestTransfer(size_t channel, size_t size, size_t count, bool srtp) {
     LOG(LS_INFO) << "Expect packets, size=" << size;
-    client2_.ExpectPackets(transport, size);
-    client1_.SendPackets(transport, size, count, srtp);
+    client2_.ExpectPackets(channel, size);
+    client1_.SendPackets(channel, size, count, srtp);
     EXPECT_EQ_SIMULATED_WAIT(count, client2_.NumPacketsReceived(), kTimeout,
                              fake_clock_);
   }
@@ -642,8 +640,8 @@
 // Test that transport negotiation of ICE, no DTLS works properly.
 TEST_F(DtlsTransportChannelTest, TestChannelSetupIce) {
   Negotiate();
-  cricket::FakeIceTransport* channel1 = client1_.GetFakeIceTransort(0);
-  cricket::FakeIceTransport* channel2 = client2_.GetFakeIceTransort(0);
+  cricket::FakeIceTransport* channel1 = client1_.GetFakeChannel(0);
+  cricket::FakeIceTransport* channel2 = client2_.GetFakeChannel(0);
   ASSERT_TRUE(channel1 != NULL);
   ASSERT_TRUE(channel2 != NULL);
   EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel1->GetIceRole());
@@ -922,9 +920,9 @@
               cricket::CONNECTIONROLE_ACTIVE, NF_REOFFER);
   bool rv = client1_.Connect(&client2_, false);
   EXPECT_TRUE(rv);
-  EXPECT_TRUE_SIMULATED_WAIT(client1_.all_dtls_transports_writable() &&
-                                 client2_.all_dtls_transports_writable(),
-                             kTimeout, fake_clock_);
+  EXPECT_TRUE_SIMULATED_WAIT(
+      client1_.all_channels_writable() && client2_.all_channels_writable(),
+      kTimeout, fake_clock_);
 
   TestTransfer(0, 1000, 100, true);
   TestTransfer(1, 1000, 100, true);
@@ -947,8 +945,8 @@
   ASSERT_TRUE(client2_.transport()->GetLocalCertificate(&certificate2));
   ASSERT_NE(certificate1->ssl_certificate().ToPEMString(),
             certificate2->ssl_certificate().ToPEMString());
-  ASSERT_FALSE(client1_.GetDtlsTransport(0)->GetRemoteSSLCertificate());
-  ASSERT_FALSE(client2_.GetDtlsTransport(0)->GetRemoteSSLCertificate());
+  ASSERT_FALSE(client1_.GetDtlsChannel(0)->GetRemoteSSLCertificate());
+  ASSERT_FALSE(client2_.GetDtlsChannel(0)->GetRemoteSSLCertificate());
 }
 
 // Test Certificates state after connection.
@@ -968,12 +966,12 @@
 
   // Each side's remote certificate is the other side's local certificate.
   std::unique_ptr<rtc::SSLCertificate> remote_cert1 =
-      client1_.GetDtlsTransport(0)->GetRemoteSSLCertificate();
+      client1_.GetDtlsChannel(0)->GetRemoteSSLCertificate();
   ASSERT_TRUE(remote_cert1);
   ASSERT_EQ(remote_cert1->ToPEMString(),
             certificate2->ssl_certificate().ToPEMString());
   std::unique_ptr<rtc::SSLCertificate> remote_cert2 =
-      client2_.GetDtlsTransport(0)->GetRemoteSSLCertificate();
+      client2_.GetDtlsChannel(0)->GetRemoteSSLCertificate();
   ASSERT_TRUE(remote_cert2);
   ASSERT_EQ(remote_cert2->ToPEMString(),
             certificate1->ssl_certificate().ToPEMString());
@@ -996,12 +994,12 @@
   // 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_ice_transports_writable(), kTimeout,
+  EXPECT_TRUE_SIMULATED_WAIT(client2_.all_raw_channels_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_ice_transports_writable());
+  EXPECT_FALSE(client1_.all_raw_channels_writable());
 
   static int timeout_schedule_ms[] = {50,   100,  200,   400,   800,   1600,
                                       3200, 6400, 12800, 25600, 51200, 60000};
@@ -1106,7 +1104,7 @@
           break;
         case CALLER_WRITABLE:
           EXPECT_TRUE(client1_.Connect(&client2_, true));
-          EXPECT_TRUE_SIMULATED_WAIT(client1_.all_ice_transports_writable(),
+          EXPECT_TRUE_SIMULATED_WAIT(client1_.all_raw_channels_writable(),
                                      kTimeout, fake_clock_);
           break;
         case CALLER_RECEIVES_CLIENTHELLO:
@@ -1114,19 +1112,19 @@
           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_ice_transports_writable(),
+          EXPECT_TRUE_SIMULATED_WAIT(client2_.all_raw_channels_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_.GetDtlsTransport(0)->IsDtlsConnected() ||
-                       client1_.GetDtlsTransport(0)->dtls_state() ==
+          EXPECT_FALSE(client1_.GetDtlsChannel(0)->IsDtlsConnected() ||
+                       client1_.GetDtlsChannel(0)->dtls_state() ==
                            cricket::DTLS_TRANSPORT_FAILED);
           EXPECT_TRUE_SIMULATED_WAIT(
-              client1_.GetDtlsTransport(0)->IsDtlsConnected() ||
-                  client1_.GetDtlsTransport(0)->dtls_state() ==
+              client1_.GetDtlsChannel(0)->IsDtlsConnected() ||
+                  client1_.GetDtlsChannel(0)->dtls_state() ==
                       cricket::DTLS_TRANSPORT_FAILED,
               kTimeout, fake_clock_);
           break;
@@ -1137,15 +1135,15 @@
         valid_fingerprint ? cricket::DTLS_TRANSPORT_CONNECTED
                           : cricket::DTLS_TRANSPORT_FAILED;
     EXPECT_EQ_SIMULATED_WAIT(expected_final_state,
-                             client1_.GetDtlsTransport(0)->dtls_state(),
-                             kTimeout, fake_clock_);
+                             client1_.GetDtlsChannel(0)->dtls_state(), kTimeout,
+                             fake_clock_);
     EXPECT_EQ_SIMULATED_WAIT(expected_final_state,
-                             client2_.GetDtlsTransport(0)->dtls_state(),
-                             kTimeout, fake_clock_);
+                             client2_.GetDtlsChannel(0)->dtls_state(), kTimeout,
+                             fake_clock_);
 
     // Channel should be writable iff there was a valid fingerprint.
-    EXPECT_EQ(valid_fingerprint, client1_.GetDtlsTransport(0)->writable());
-    EXPECT_EQ(valid_fingerprint, client2_.GetDtlsTransport(0)->writable());
+    EXPECT_EQ(valid_fingerprint, client1_.GetDtlsChannel(0)->writable());
+    EXPECT_EQ(valid_fingerprint, client2_.GetDtlsChannel(0)->writable());
 
     // Check that no hello needed to be retransmitted.
     EXPECT_EQ(1, client1_.received_dtls_client_hellos());