Renamed dtlstransportchannel.h/.cc/_unittest.cc.

webrtc/p2p/base/dtlstransport_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 <algorithm>
 #include <memory>
 #include <set>
 
-#include "webrtc/p2p/base/dtlstransportchannel.h"
+#include "webrtc/p2p/base/dtlstransport.h"
 #include "webrtc/p2p/base/fakeicetransport.h"
 #include "webrtc/p2p/base/packettransportinternal.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/dscp.h"
 #include "webrtc/rtc_base/gunit.h"
 #include "webrtc/rtc_base/helpers.h"
 #include "webrtc/rtc_base/ssladapter.h"
 #include "webrtc/rtc_base/sslidentity.h"
 #include "webrtc/rtc_base/sslstreamadapter.h"
 #include "webrtc/rtc_base/stringutils.h"
@@ skipping 36 matching lines @@
 
 using cricket::ConnectionRole;
 
 enum Flags { NF_REOFFER = 0x1, NF_EXPECT_FAILURE = 0x2 };
 
 // TODO(deadbeef): Remove the dependency on JsepTransport. This test should be
 // testing DtlsTransportChannel by itself, calling methods to set the
 // configuration directly instead of negotiating TransportDescriptions.
 class DtlsTestClient : public sigslot::has_slots<> {
  public:
-  DtlsTestClient(const std::string& name) : name_(name) {}
+  explicit DtlsTestClient(const std::string& name) : name_(name) {}
   void CreateCertificate(rtc::KeyType key_type) {
     certificate_ =
         rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
             rtc::SSLIdentity::Generate(name_, key_type)));
   }
   const rtc::scoped_refptr<rtc::RTCCertificate>& certificate() {
     return certificate_;
   }
   void SetupMaxProtocolVersion(rtc::SSLProtocolVersion version) {
     ssl_max_version_ = version;
@@ skipping 45 matching lines @@
     for (const auto& dtls : 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,
+  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 SetLocalTransportDescription(
       const rtc::scoped_refptr<rtc::RTCCertificate>& cert,
       cricket::ContentAction action,
       ConnectionRole role,
       int flags) {
@@ skipping 163 matching lines @@
     rtc::PacketOptions packet_options;
     return dtls_transports_[transport]->SendPacket(
         packet.get(), size, packet_options, cricket::PF_SRTP_BYPASS);
   }
 
   void ExpectPackets(size_t transport, size_t size) {
     packet_size_ = size;
     received_.clear();
   }
 
-  size_t NumPacketsReceived() {
-    return received_.size();
-  }
+  size_t NumPacketsReceived() { return received_.size(); }
 
   bool VerifyPacket(const char* data, size_t size, uint32_t* out_num) {
     if (size != packet_size_ ||
         (data[0] != 0 && static_cast<uint8_t>(data[0]) != 0x80)) {
       return false;
     }
     uint32_t packet_num = rtc::GetBE32(data + kPacketNumOffset);
     for (size_t i = kPacketHeaderLen; i < size; ++i) {
       if (static_cast<uint8_t>(data[i]) != (packet_num & 0xff)) {
         return false;
@@ skipping 159 matching lines @@
                                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;
+            client1_role == cricket::CONNECTIONROLE_ACTPASS))
+              ? rtc::SSL_CLIENT
+              : rtc::SSL_SERVER;
 
       rtc::SSLRole client2_ssl_role =
           (client2_role == cricket::CONNECTIONROLE_ACTIVE ||
            (client1_role == cricket::CONNECTIONROLE_PASSIVE &&
-            client2_role == cricket::CONNECTIONROLE_ACTPASS)) ?
-              rtc::SSL_CLIENT : rtc::SSL_SERVER;
+            client2_role == cricket::CONNECTIONROLE_ACTPASS))
+              ? rtc::SSL_CLIENT
+              : rtc::SSL_SERVER;
 
       client1_.CheckRole(client1_ssl_role);
       client2_.CheckRole(client2_ssl_role);
     }
 
     if (use_dtls_) {
       // Check that we negotiated the right ciphers. Since GCM ciphers are not
       // negotiated by default, we should end up with SRTP_AES128_CM_SHA1_32.
       client1_.CheckSrtp(rtc::SRTP_AES128_CM_SHA1_32);
       client2_.CheckSrtp(rtc::SRTP_AES128_CM_SHA1_32);
@@ skipping 17 matching lines @@
   }
 
   void Negotiate() {
     Negotiate(cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_ACTIVE);
   }
 
   void Negotiate(ConnectionRole client1_role, ConnectionRole client2_role) {
     client1_.SetupChannels(channel_ct_, cricket::ICEROLE_CONTROLLING);
     client2_.SetupChannels(channel_ct_, cricket::ICEROLE_CONTROLLED);
     // Expect success from SLTD and SRTD.
-    client1_.Negotiate(&client2_, cricket::CA_OFFER,
-                       client1_role, client2_role, 0);
-    client2_.Negotiate(&client1_, cricket::CA_ANSWER,
-                       client2_role, client1_role, 0);
+    client1_.Negotiate(&client2_, cricket::CA_OFFER, client1_role, client2_role,
+                       0);
+    client2_.Negotiate(&client1_, cricket::CA_ANSWER, client2_role,
+                       client1_role, 0);
   }
 
   // Negotiate with legacy client |client2|. Legacy client doesn't use setup
   // attributes, except NONE.
   void NegotiateWithLegacy() {
     client1_.SetupChannels(channel_ct_, cricket::ICEROLE_CONTROLLING);
     client2_.SetupChannels(channel_ct_, cricket::ICEROLE_CONTROLLED);
     // Expect success from SLTD and SRTD.
     client1_.Negotiate(&client2_, cricket::CA_OFFER,
                        cricket::CONNECTIONROLE_ACTPASS,
                        cricket::CONNECTIONROLE_NONE, 0);
     client2_.Negotiate(&client1_, cricket::CA_ANSWER,
                        cricket::CONNECTIONROLE_ACTIVE,
                        cricket::CONNECTIONROLE_NONE, 0);
   }
 
   void Renegotiate(DtlsTestClient* reoffer_initiator,
-                   ConnectionRole client1_role, ConnectionRole client2_role,
+                   ConnectionRole client1_role,
+                   ConnectionRole client2_role,
                    int flags) {
     if (reoffer_initiator == &client1_) {
-      client1_.Negotiate(&client2_, cricket::CA_OFFER,
-                         client1_role, client2_role, flags);
-      client2_.Negotiate(&client1_, cricket::CA_ANSWER,
-                         client2_role, client1_role, flags);
+      client1_.Negotiate(&client2_, cricket::CA_OFFER, client1_role,
+                         client2_role, flags);
+      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);
+      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 transport, 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);
     EXPECT_EQ_SIMULATED_WAIT(count, client2_.NumPacketsReceived(), kTimeout,
                              fake_clock_);
   }
@@ skipping 203 matching lines @@
   EXPECT_EQ(rtc::SSL_SERVER, *client1_.transport()->GetSslRole());
   EXPECT_EQ(rtc::SSL_CLIENT, *client2_.transport()->GetSslRole());
 }
 
 // Testing re offer/answer after the session is estbalished. Roles will be
 // kept same as of the previous negotiation.
 TEST_F(DtlsTransportChannelTest, TestDtlsReOfferFromOfferer) {
   SetChannelCount(2);
   PrepareDtls(true, true, rtc::KT_DEFAULT);
   // Initial role for client1 is ACTPASS and client2 is ACTIVE.
-  ASSERT_TRUE(Connect(cricket::CONNECTIONROLE_ACTPASS,
-                      cricket::CONNECTIONROLE_ACTIVE));
+  ASSERT_TRUE(
+      Connect(cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_ACTIVE));
   TestTransfer(0, 1000, 100, true);
   TestTransfer(1, 1000, 100, true);
   // Using input roles for the re-offer.
   Renegotiate(&client1_, cricket::CONNECTIONROLE_ACTPASS,
               cricket::CONNECTIONROLE_ACTIVE, NF_REOFFER);
   TestTransfer(0, 1000, 100, true);
   TestTransfer(1, 1000, 100, true);
 }
 
 TEST_F(DtlsTransportChannelTest, TestDtlsReOfferFromAnswerer) {
   SetChannelCount(2);
   PrepareDtls(true, true, rtc::KT_DEFAULT);
   // Initial role for client1 is ACTPASS and client2 is ACTIVE.
-  ASSERT_TRUE(Connect(cricket::CONNECTIONROLE_ACTPASS,
-                      cricket::CONNECTIONROLE_ACTIVE));
+  ASSERT_TRUE(
+      Connect(cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_ACTIVE));
   TestTransfer(0, 1000, 100, true);
   TestTransfer(1, 1000, 100, true);
   // Using input roles for the re-offer.
   Renegotiate(&client2_, cricket::CONNECTIONROLE_PASSIVE,
               cricket::CONNECTIONROLE_ACTPASS, NF_REOFFER);
   TestTransfer(0, 1000, 100, true);
   TestTransfer(1, 1000, 100, true);
 }
 
 // Test that any change in role after the intial setup will result in failure.
 TEST_F(DtlsTransportChannelTest, TestDtlsRoleReversal) {
   SetChannelCount(2);
   PrepareDtls(true, true, rtc::KT_DEFAULT);
   ASSERT_TRUE(Connect(cricket::CONNECTIONROLE_ACTPASS,
                       cricket::CONNECTIONROLE_PASSIVE));
 
   // Renegotiate from client2 with actpass and client1 as active.
   Renegotiate(&client2_, cricket::CONNECTIONROLE_ACTPASS,
-              cricket::CONNECTIONROLE_ACTIVE,
-              NF_REOFFER | NF_EXPECT_FAILURE);
+              cricket::CONNECTIONROLE_ACTIVE, NF_REOFFER | NF_EXPECT_FAILURE);
 }
 
 // Test that using different setup attributes which results in similar ssl
 // role as the initial negotiation will result in success.
 TEST_F(DtlsTransportChannelTest, TestDtlsReOfferWithDifferentSetupAttr) {
   SetChannelCount(2);
   PrepareDtls(true, true, rtc::KT_DEFAULT);
   ASSERT_TRUE(Connect(cricket::CONNECTIONROLE_ACTPASS,
                       cricket::CONNECTIONROLE_PASSIVE));
   // Renegotiate from client2 with actpass and client1 as active.
@@ skipping 273 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()));