Reland Convert internal representation of Srtp cryptos from string to int

talk/session/media/mediasession.cc

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 32 matching lines @@
 #include "webrtc/p2p/base/constants.h"
 
 #ifdef HAVE_SCTP
 #include "talk/media/sctp/sctpdataengine.h"
 #else
 static const uint32_t kMaxSctpSid = 1023;
 #endif
 
 namespace {
 const char kInline[] = "inline:";
+
+void GetSupportedCryptoSuiteNames(void (*func)(std::vector<int>*),
+                                  std::vector<std::string>* names) {
+#ifdef HAVE_SRTP
+  std::vector<int> crypto_suites;
+  func(&crypto_suites);
+  for (const auto crypto : crypto_suites) {
+    names->push_back(rtc::SrtpCryptoSuiteToName(crypto));
+  }
+#endif
+}
 }
 
 namespace cricket {
 
 using rtc::scoped_ptr;
 
 // RTP Profile names
 // http://www.iana.org/assignments/rtp-parameters/rtp-parameters.xml
 // RFC4585
 const char kMediaProtocolAvpf[] = "RTP/AVPF";
@@ skipping 82 matching lines @@
        it != cryptos.end(); ++it) {
     if (crypto.Matches(*it)) {
       *out = *it;
       return true;
     }
   }
   return false;
 }
 
 // For audio, HMAC 32 is prefered because of the low overhead.
-void GetSupportedAudioCryptoSuites(
-    std::vector<std::string>* crypto_suites) {
+void GetSupportedAudioCryptoSuites(std::vector<int>* crypto_suites) {
 #ifdef HAVE_SRTP
-  crypto_suites->push_back(rtc::CS_AES_CM_128_HMAC_SHA1_32);
-  crypto_suites->push_back(rtc::CS_AES_CM_128_HMAC_SHA1_80);
+  crypto_suites->push_back(rtc::SRTP_AES128_CM_SHA1_32);
+  crypto_suites->push_back(rtc::SRTP_AES128_CM_SHA1_80);
 #endif
 }
 
-void GetSupportedVideoCryptoSuites(
-    std::vector<std::string>* crypto_suites) {
-  GetDefaultSrtpCryptoSuiteNames(crypto_suites);
+void GetSupportedAudioCryptoSuiteNames(
+    std::vector<std::string>* crypto_suite_names) {
+  GetSupportedCryptoSuiteNames(GetSupportedAudioCryptoSuites,
+                               crypto_suite_names);
 }
 
-void GetSupportedDataCryptoSuites(
-    std::vector<std::string>* crypto_suites) {
-  GetDefaultSrtpCryptoSuiteNames(crypto_suites);
+void GetSupportedVideoCryptoSuites(std::vector<int>* crypto_suites) {
+  GetDefaultSrtpCryptoSuites(crypto_suites);
 }
 
-void GetDefaultSrtpCryptoSuiteNames(std::vector<std::string>* crypto_suites) {
+void GetSupportedVideoCryptoSuiteNames(
+    std::vector<std::string>* crypto_suite_names) {
+  GetSupportedCryptoSuiteNames(GetSupportedVideoCryptoSuites,
+                               crypto_suite_names);
+}
+
+void GetSupportedDataCryptoSuites(std::vector<int>* crypto_suites) {
+  GetDefaultSrtpCryptoSuites(crypto_suites);
+}
+
+void GetSupportedDataCryptoSuiteNames(
+    std::vector<std::string>* crypto_suite_names) {
+  GetSupportedCryptoSuiteNames(GetSupportedDataCryptoSuites,
+                               crypto_suite_names);
+}
+
+void GetDefaultSrtpCryptoSuites(std::vector<int>* crypto_suites) {
 #ifdef HAVE_SRTP
-  crypto_suites->push_back(rtc::CS_AES_CM_128_HMAC_SHA1_80);
+  crypto_suites->push_back(rtc::SRTP_AES128_CM_SHA1_80);
 #endif
 }
 
+void GetDefaultSrtpCryptoSuiteNames(
+    std::vector<std::string>* crypto_suite_names) {
+  GetSupportedCryptoSuiteNames(GetDefaultSrtpCryptoSuites, crypto_suite_names);
+}
+
 // For video support only 80-bit SHA1 HMAC. For audio 32-bit HMAC is
 // tolerated unless bundle is enabled because it is low overhead. Pick the
 // crypto in the list that is supported.
 static bool SelectCrypto(const MediaContentDescription* offer,
                          bool bundle,
                          CryptoParams *crypto) {
   bool audio = offer->type() == MEDIA_TYPE_AUDIO;
   const CryptoParamsVec& cryptos = offer->cryptos();
 
   for (CryptoParamsVec::const_iterator i = cryptos.begin();
@@ skipping 1318 matching lines @@
     const RtpHeaderExtensions& audio_rtp_extensions,
     const AudioCodecs& audio_codecs,
     StreamParamsVec* current_streams,
     SessionDescription* desc) const {
   cricket::SecurePolicy sdes_policy =
       IsDtlsActive(CN_AUDIO, current_description) ?
           cricket::SEC_DISABLED : secure();
 
   scoped_ptr<AudioContentDescription> audio(new AudioContentDescription());
   std::vector<std::string> crypto_suites;
-  GetSupportedAudioCryptoSuites(&crypto_suites);
+  GetSupportedAudioCryptoSuiteNames(&crypto_suites);
   if (!CreateMediaContentOffer(
           options,
           audio_codecs,
           sdes_policy,
           GetCryptos(GetFirstAudioContentDescription(current_description)),
           crypto_suites,
           audio_rtp_extensions,
           add_legacy_,
           current_streams,
           audio.get())) {
@@ skipping 33 matching lines @@
     const RtpHeaderExtensions& video_rtp_extensions,
     const VideoCodecs& video_codecs,
     StreamParamsVec* current_streams,
     SessionDescription* desc) const {
   cricket::SecurePolicy sdes_policy =
       IsDtlsActive(CN_VIDEO, current_description) ?
           cricket::SEC_DISABLED : secure();
 
   scoped_ptr<VideoContentDescription> video(new VideoContentDescription());
   std::vector<std::string> crypto_suites;
-  GetSupportedVideoCryptoSuites(&crypto_suites);
+  GetSupportedVideoCryptoSuiteNames(&crypto_suites);
   if (!CreateMediaContentOffer(
           options,
           video_codecs,
           sdes_policy,
           GetCryptos(GetFirstVideoContentDescription(current_description)),
           crypto_suites,
           video_rtp_extensions,
           add_legacy_,
           current_streams,
           video.get())) {
@@ skipping 49 matching lines @@
     // SDES doesn't make sense for SCTP, so we disable it, and we only
     // get SDES crypto suites for RTP-based data channels.
     sdes_policy = cricket::SEC_DISABLED;
     // Unlike SetMediaProtocol below, we need to set the protocol
     // before we call CreateMediaContentOffer.  Otherwise,
     // CreateMediaContentOffer won't know this is SCTP and will
     // generate SSRCs rather than SIDs.
     data->set_protocol(
         secure_transport ? kMediaProtocolDtlsSctp : kMediaProtocolSctp);
   } else {
-    GetSupportedDataCryptoSuites(&crypto_suites);
+    GetSupportedDataCryptoSuiteNames(&crypto_suites);
   }
 
   if (!CreateMediaContentOffer(
           options,
           *data_codecs,
           sdes_policy,
           GetCryptos(GetFirstDataContentDescription(current_description)),
           crypto_suites,
           RtpHeaderExtensions(),
           add_legacy_,
@@ skipping 272 matching lines @@
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_VIDEO));
 }
 
 const DataContentDescription* GetFirstDataContentDescription(
     const SessionDescription* sdesc) {
   return static_cast<const DataContentDescription*>(
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_DATA));
 }
 
 }  // namespace cricket