Convert internal representation of Srtp cryptos from string to int.

webrtc/base/sslstreamadapter_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 11 matching lines @@
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/base/stream.h"
 #include "webrtc/test/testsupport/gtest_disable.h"
 
 using ::testing::WithParamInterface;
 using ::testing::Values;
 using ::testing::Combine;
 using ::testing::tuple;
 
 static const int kBlockSize = 4096;
-static const char kAES_CM_HMAC_SHA1_80[] = "AES_CM_128_HMAC_SHA1_80";
-static const char kAES_CM_HMAC_SHA1_32[] = "AES_CM_128_HMAC_SHA1_32";
 static const char kExporterLabel[] = "label";
 static const unsigned char kExporterContext[] = "context";
 static int kExporterContextLen = sizeof(kExporterContext);
 
 static const char kRSA_PRIVATE_KEY_PEM[] =
     "-----BEGIN RSA PRIVATE KEY-----\n"
     "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAMYRkbhmI7kVA/rM\n"
     "czsZ+6JDhDvnkF+vn6yCAGuRPV03zuRqZtDy4N4to7PZu9PjqrRl7nDMXrG3YG9y\n"
     "rlIAZ72KjcKKFAJxQyAKLCIdawKRyp8RdK3LEySWEZb0AV58IadqPZDTNHHRX8dz\n"
     "5aTSMsbbkZ+C/OzTnbiMqLL/vg6jAgMBAAECgYAvgOs4FJcgvp+TuREx7YtiYVsH\n"
@@ skipping 338 matching lines @@
   }
 
   void SetMtu(size_t mtu) {
     mtu_ = mtu;
   }
 
   void SetHandshakeWait(int wait) {
     handshake_wait_ = wait;
   }
 
-  void SetDtlsSrtpCiphers(const std::vector<std::string> &ciphers,
-    bool client) {
+  void SetDtlsSrtpCryptoSuites(const std::vector<int>& ciphers, bool client) {
     if (client)
-      client_ssl_->SetDtlsSrtpCiphers(ciphers);
+      client_ssl_->SetDtlsSrtpCryptoSuites(ciphers);
     else
-      server_ssl_->SetDtlsSrtpCiphers(ciphers);
+      server_ssl_->SetDtlsSrtpCryptoSuites(ciphers);
   }
 
-  bool GetDtlsSrtpCipher(bool client, std::string *retval) {
+  bool GetDtlsSrtpCryptoSuite(bool client, int* retval) {
     if (client)
-      return client_ssl_->GetDtlsSrtpCipher(retval);
+      return client_ssl_->GetDtlsSrtpCryptoSuite(retval);
     else
-      return server_ssl_->GetDtlsSrtpCipher(retval);
+      return server_ssl_->GetDtlsSrtpCryptoSuite(retval);
   }
 
   bool GetPeerCertificate(bool client, rtc::SSLCertificate** cert) {
     if (client)
       return client_ssl_->GetPeerCertificate(cert);
     else
       return server_ssl_->GetPeerCertificate(cert);
   }
 
   bool GetSslCipherSuite(bool client, int* retval) {
@@ skipping 387 matching lines @@
   MAYBE_SKIP_TEST(HaveDtls);
   SetDamage();  // Must be called first because first packet
                 // write happens at end of handshake.
   TestHandshake();
   TestTransfer(100);
 };
 
 // Test DTLS-SRTP with all high ciphers
 TEST_P(SSLStreamAdapterTestDTLS, TestDTLSSrtpHigh) {
   MAYBE_SKIP_TEST(HaveDtlsSrtp);
-  std::vector<std::string> high;
-  high.push_back(kAES_CM_HMAC_SHA1_80);
-  SetDtlsSrtpCiphers(high, true);
-  SetDtlsSrtpCiphers(high, false);
+  std::vector<int> high;
+  high.push_back(rtc::SRTP_AES128_CM_SHA1_80);
+  SetDtlsSrtpCryptoSuites(high, true);
+  SetDtlsSrtpCryptoSuites(high, false);
   TestHandshake();
 
-  std::string client_cipher;
-  ASSERT_TRUE(GetDtlsSrtpCipher(true, &client_cipher));
-  std::string server_cipher;
-  ASSERT_TRUE(GetDtlsSrtpCipher(false, &server_cipher));
+  int client_cipher;
+  ASSERT_TRUE(GetDtlsSrtpCryptoSuite(true, &client_cipher));
+  int server_cipher;
+  ASSERT_TRUE(GetDtlsSrtpCryptoSuite(false, &server_cipher));
 
   ASSERT_EQ(client_cipher, server_cipher);
-  ASSERT_EQ(client_cipher, kAES_CM_HMAC_SHA1_80);
+  ASSERT_EQ(client_cipher, rtc::SRTP_AES128_CM_SHA1_80);
 };
 
 // Test DTLS-SRTP with all low ciphers
 TEST_P(SSLStreamAdapterTestDTLS, TestDTLSSrtpLow) {
   MAYBE_SKIP_TEST(HaveDtlsSrtp);
-  std::vector<std::string> low;
-  low.push_back(kAES_CM_HMAC_SHA1_32);
-  SetDtlsSrtpCiphers(low, true);
-  SetDtlsSrtpCiphers(low, false);
+  std::vector<int> low;
+  low.push_back(rtc::SRTP_AES128_CM_SHA1_32);
+  SetDtlsSrtpCryptoSuites(low, true);
+  SetDtlsSrtpCryptoSuites(low, false);
   TestHandshake();
 
-  std::string client_cipher;
-  ASSERT_TRUE(GetDtlsSrtpCipher(true, &client_cipher));
-  std::string server_cipher;
-  ASSERT_TRUE(GetDtlsSrtpCipher(false, &server_cipher));
+  int client_cipher;
+  ASSERT_TRUE(GetDtlsSrtpCryptoSuite(true, &client_cipher));
+  int server_cipher;
+  ASSERT_TRUE(GetDtlsSrtpCryptoSuite(false, &server_cipher));
 
   ASSERT_EQ(client_cipher, server_cipher);
-  ASSERT_EQ(client_cipher, kAES_CM_HMAC_SHA1_32);
+  ASSERT_EQ(client_cipher, rtc::SRTP_AES128_CM_SHA1_32);
 };
 
 
 // Test DTLS-SRTP with a mismatch -- should not converge
 TEST_P(SSLStreamAdapterTestDTLS, TestDTLSSrtpHighLow) {
   MAYBE_SKIP_TEST(HaveDtlsSrtp);
-  std::vector<std::string> high;
-  high.push_back(kAES_CM_HMAC_SHA1_80);
-  std::vector<std::string> low;
-  low.push_back(kAES_CM_HMAC_SHA1_32);
-  SetDtlsSrtpCiphers(high, true);
-  SetDtlsSrtpCiphers(low, false);
+  std::vector<int> high;
+  high.push_back(rtc::SRTP_AES128_CM_SHA1_80);
+  std::vector<int> low;
+  low.push_back(rtc::SRTP_AES128_CM_SHA1_32);
+  SetDtlsSrtpCryptoSuites(high, true);
+  SetDtlsSrtpCryptoSuites(low, false);
   TestHandshake();
 
-  std::string client_cipher;
-  ASSERT_FALSE(GetDtlsSrtpCipher(true, &client_cipher));
-  std::string server_cipher;
-  ASSERT_FALSE(GetDtlsSrtpCipher(false, &server_cipher));
+  int client_cipher;
+  ASSERT_FALSE(GetDtlsSrtpCryptoSuite(true, &client_cipher));
+  int server_cipher;
+  ASSERT_FALSE(GetDtlsSrtpCryptoSuite(false, &server_cipher));
 };
 
 // Test DTLS-SRTP with each side being mixed -- should select high
 TEST_P(SSLStreamAdapterTestDTLS, TestDTLSSrtpMixed) {
   MAYBE_SKIP_TEST(HaveDtlsSrtp);
-  std::vector<std::string> mixed;
-  mixed.push_back(kAES_CM_HMAC_SHA1_80);
-  mixed.push_back(kAES_CM_HMAC_SHA1_32);
-  SetDtlsSrtpCiphers(mixed, true);
-  SetDtlsSrtpCiphers(mixed, false);
+  std::vector<int> mixed;
+  mixed.push_back(rtc::SRTP_AES128_CM_SHA1_80);
+  mixed.push_back(rtc::SRTP_AES128_CM_SHA1_32);
+  SetDtlsSrtpCryptoSuites(mixed, true);
+  SetDtlsSrtpCryptoSuites(mixed, false);
   TestHandshake();
 
-  std::string client_cipher;
-  ASSERT_TRUE(GetDtlsSrtpCipher(true, &client_cipher));
-  std::string server_cipher;
-  ASSERT_TRUE(GetDtlsSrtpCipher(false, &server_cipher));
+  int client_cipher;
+  ASSERT_TRUE(GetDtlsSrtpCryptoSuite(true, &client_cipher));
+  int server_cipher;
+  ASSERT_TRUE(GetDtlsSrtpCryptoSuite(false, &server_cipher));
 
   ASSERT_EQ(client_cipher, server_cipher);
-  ASSERT_EQ(client_cipher, kAES_CM_HMAC_SHA1_80);
+  ASSERT_EQ(client_cipher, rtc::SRTP_AES128_CM_SHA1_80);
 };
 
 // Test an exporter
 TEST_P(SSLStreamAdapterTestDTLS, TestDTLSExporter) {
   MAYBE_SKIP_TEST(HaveExporter);
   TestHandshake();
   unsigned char client_out[20];
   unsigned char server_out[20];
 
   bool result;
@@ skipping 164 matching lines @@
                    rtc::KeyParams::ECDSA(rtc::EC_NIST_P256))));
 INSTANTIATE_TEST_CASE_P(
     SSLStreamAdapterTestsDTLS,
     SSLStreamAdapterTestDTLS,
     Combine(Values(rtc::KeyParams::RSA(1024, 65537),
                    rtc::KeyParams::RSA(1152, 65537),
                    rtc::KeyParams::ECDSA(rtc::EC_NIST_P256)),
             Values(rtc::KeyParams::RSA(1024, 65537),
                    rtc::KeyParams::RSA(1152, 65537),
                    rtc::KeyParams::ECDSA(rtc::EC_NIST_P256))));