Refactoring that removes P2PTransport and DtlsTransport classes.

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.
  */
 
 #include <memory>
 #include <set>
 
-#include "webrtc/p2p/base/dtlstransport.h"
+#include "webrtc/p2p/base/dtlstransportchannel.h"
 #include "webrtc/p2p/base/faketransportcontroller.h"
 #include "webrtc/p2p/base/packettransportinterface.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/dscp.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/base/stringutils.h"
@@ skipping 47 matching lines @@
             rtc::SSLIdentity::Generate(name_, key_type)));
   }
   const rtc::scoped_refptr<rtc::RTCCertificate>& certificate() {
     return certificate_;
   }
   void SetupSrtp() {
     ASSERT(certificate_);
     use_dtls_srtp_ = true;
   }
   void SetupMaxProtocolVersion(rtc::SSLProtocolVersion version) {
-    ASSERT(!transport_);
     ssl_max_version_ = version;
   }
   void SetupChannels(int count, cricket::IceRole role, int async_delay_ms = 0) {
-    transport_.reset(new cricket::DtlsTransport<cricket::FakeTransport>(
-        "dtls content name", nullptr, certificate_));
-    transport_->SetAsync(true);
-    transport_->SetAsyncDelay(async_delay_ms);
-    transport_->SetIceRole(role);
-    transport_->SetIceTiebreaker(
-        (role == cricket::ICEROLE_CONTROLLING) ? 1 : 2);
+    transport_.reset(new cricket::Transport("dtls content name", certificate_));
+    for (int i = 0; i < count; ++i) {
+      cricket::FakeTransportChannel* fake_ice_channel =
+          new cricket::FakeTransportChannel(transport_->name(), 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);
 
-    for (int i = 0; i < count; ++i) {
       cricket::DtlsTransportChannelWrapper* channel =
-          static_cast<cricket::DtlsTransportChannelWrapper*>(
-              transport_->CreateChannel(i));
-      ASSERT_TRUE(channel != NULL);
+          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);
-      channels_.push_back(channel);
-
-      // Hook the raw packets so that we can verify they are encrypted.
-      channel->channel()->SignalReadPacket.connect(
-          this, &DtlsTestClient::OnFakeTransportChannelReadPacket);
+      channels_.push_back(
+          std::unique_ptr<cricket::DtlsTransportChannelWrapper>(channel));
+      fake_channels_.push_back(
+          std::unique_ptr<cricket::FakeTransportChannel>(fake_ice_channel));
+      transport_->AddChannel(channel, fake_ice_channel, i);
     }
   }
 
   cricket::Transport* transport() { return transport_.get(); }
 
   cricket::FakeTransportChannel* GetFakeChannel(int component) {
-    cricket::TransportChannelImpl* ch = transport_->GetChannel(component);
-    cricket::DtlsTransportChannelWrapper* wrapper =
-        static_cast<cricket::DtlsTransportChannelWrapper*>(ch);
-    return (wrapper) ?
-        static_cast<cricket::FakeTransportChannel*>(wrapper->channel()) : NULL;
+    for (const auto& ch : fake_channels_) {
+      if (ch->component() == component) {
+        return ch.get();
+      }
+    }
+    return nullptr;
   }
 
   cricket::DtlsTransportChannelWrapper* GetDtlsChannel(int component) {
-    cricket::TransportChannelImpl* ch = transport_->GetChannel(component);
-    return static_cast<cricket::DtlsTransportChannelWrapper*>(ch);
+    for (const auto& ch : channels_) {
+      if (ch->component() == component) {
+        return ch.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 (cricket::DtlsTransportChannelWrapper* channel : channels_) {
+    for (const auto& channel : channels_) {
       EXPECT_TRUE(channel->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
@@ skipping 39 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) {
-    transport_->SetDestination(peer->transport_.get(), asymmetric);
+    for (auto& channel : fake_channels_) {
+      channel->SetDestination(peer->GetFakeChannel(channel->component()),
+                              asymmetric);
+    }
     return true;
   }
 
   bool all_channels_writable() const {
     if (channels_.empty()) {
       return false;
     }
-    for (cricket::DtlsTransportChannelWrapper* channel : channels_) {
+    for (const auto& channel : channels_) {
       if (!channel->writable()) {
         return false;
       }
     }
     return true;
   }
 
   bool all_raw_channels_writable() const {
     if (channels_.empty()) {
       return false;
     }
-    for (cricket::DtlsTransportChannelWrapper* channel : channels_) {
+    for (const auto& channel : channels_) {
       if (!channel->channel()->writable()) {
         return false;
       }
     }
     return true;
   }
 
   int received_dtls_client_hellos() const {
     return received_dtls_client_hellos_;
   }
@@ skipping 13 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 (std::vector<cricket::DtlsTransportChannelWrapper*>::iterator it =
-           channels_.begin(); it != channels_.end(); ++it) {
+    for (const auto& channel : channels_) {
       int crypto_suite;
 
-      bool rv = (*it)->GetSrtpCryptoSuite(&crypto_suite);
+      bool rv = channel->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 (std::vector<cricket::DtlsTransportChannelWrapper*>::iterator it =
-           channels_.begin(); it != channels_.end(); ++it) {
+    for (const auto& channel : channels_) {
       int cipher;
 
-      bool rv = (*it)->GetSslCipherSuite(&cipher);
+      bool rv = channel->GetSslCipherSuite(&cipher);
       if (negotiated_dtls()) {
         ASSERT_TRUE(rv);
 
         EXPECT_TRUE(
             rtc::SSLStreamAdapter::IsAcceptableCipher(cipher, rtc::KT_DEFAULT));
       } else {
         ASSERT_FALSE(rv);
       }
     }
   }
@@ skipping 126 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::unique_ptr<cricket::FakeTransport> transport_;
-  std::vector<cricket::DtlsTransportChannelWrapper*> channels_;
+  std::vector<std::unique_ptr<cricket::FakeTransportChannel>> fake_channels_;
+  std::vector<std::unique_ptr<cricket::DtlsTransportChannelWrapper>> channels_;
+  std::unique_ptr<cricket::Transport> 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_;
 };
 
 // Base class for DtlsTransportChannelTest and DtlsEventOrderingTest, which
@@ skipping 376 matching lines @@
 }
 
 // Testing with the legacy DTLS client which doesn't use setup attribute.
 // In this case legacy is the answerer.
 TEST_F(DtlsTransportChannelTest, TestDtlsSetupWithLegacyAsAnswerer) {
   MAYBE_SKIP_TEST(HaveDtlsSrtp);
   PrepareDtls(true, true, rtc::KT_DEFAULT);
   NegotiateWithLegacy();
   rtc::SSLRole channel1_role;
   rtc::SSLRole channel2_role;
-  EXPECT_TRUE(client1_.transport()->GetSslRole(&channel1_role));
-  EXPECT_TRUE(client2_.transport()->GetSslRole(&channel2_role));
+  client1_.transport()->GetSslRole(&channel1_role);
+  client2_.transport()->GetSslRole(&channel2_role);
   EXPECT_EQ(rtc::SSL_SERVER, channel1_role);
   EXPECT_EQ(rtc::SSL_CLIENT, channel2_role);
 }
 
 // Testing re offer/answer after the session is estbalished. Roles will be
 // kept same as of the previous negotiation.
 TEST_F(DtlsTransportChannelTest, TestDtlsReOfferFromOfferer) {
   MAYBE_SKIP_TEST(HaveDtlsSrtp);
   SetChannelCount(2);
   PrepareDtls(true, true, rtc::KT_DEFAULT);
@@ skipping 89 matching lines @@
   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_.transport()->GetRemoteSSLCertificate());
-  ASSERT_FALSE(client2_.transport()->GetRemoteSSLCertificate());
+  ASSERT_FALSE(client1_.GetDtlsChannel(0)->GetRemoteSSLCertificate());
+  ASSERT_FALSE(client2_.GetDtlsChannel(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_.transport()->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_.transport()->GetRemoteSSLCertificate();
+      client2_.GetDtlsChannel(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) {
@@ skipping 199 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()));