Remove HAVE_SRTP define and unmaintained code.

webrtc/pc/mediasession.cc

 /*
  *  Copyright 2004 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 21 matching lines @@
 #include "webrtc/pc/channelmanager.h"
 #include "webrtc/pc/srtpfilter.h"
 
 namespace {
 const char kInline[] = "inline:";
 
 void GetSupportedCryptoSuiteNames(void (*func)(const rtc::CryptoOptions&,
                                       std::vector<int>*),
                                   const rtc::CryptoOptions& crypto_options,
                                   std::vector<std::string>* names) {
-#ifdef HAVE_SRTP
   std::vector<int> crypto_suites;
   func(crypto_options, &crypto_suites);
   for (const auto crypto : crypto_suites) {
     names->push_back(rtc::SrtpCryptoSuiteToName(crypto));
   }
-#endif
 }
 }  // namespace
 
 namespace cricket {
 
 // RTP Profile names
 // http://www.iana.org/assignments/rtp-parameters/rtp-parameters.xml
 // RFC4585
 const char kMediaProtocolAvpf[] = "RTP/AVPF";
 // RFC5124
@@ skipping 65 matching lines @@
   RTC_CHECK_EQ(master_key_len, master_key.size());
   std::string key = rtc::Base64::Encode(master_key);
 
   out->tag = tag;
   out->cipher_suite = cipher;
   out->key_params = kInline;
   out->key_params += key;
   return true;
 }
 
-#ifdef HAVE_SRTP
 static bool AddCryptoParams(const std::string& cipher_suite,
                             CryptoParamsVec *out) {
   int size = static_cast<int>(out->size());
 
   out->resize(size + 1);
   return CreateCryptoParams(size, cipher_suite, &out->at(size));
 }
 
 void AddMediaCryptos(const CryptoParamsVec& cryptos,
                      MediaContentDescription* media) {
   for (CryptoParamsVec::const_iterator crypto = cryptos.begin();
        crypto != cryptos.end(); ++crypto) {
     media->AddCrypto(*crypto);
   }
 }
 
 bool CreateMediaCryptos(const std::vector<std::string>& crypto_suites,
                         MediaContentDescription* media) {
   CryptoParamsVec cryptos;
   for (std::vector<std::string>::const_iterator it = crypto_suites.begin();
        it != crypto_suites.end(); ++it) {
     if (!AddCryptoParams(*it, &cryptos)) {
       return false;
     }
   }
   AddMediaCryptos(cryptos, media);
   return true;
 }
-#endif
 
 const CryptoParamsVec* GetCryptos(const MediaContentDescription* media) {
   if (!media) {
     return NULL;
   }
   return &media->cryptos();
 }
 
 bool FindMatchingCrypto(const CryptoParamsVec& cryptos,
                         const CryptoParams& crypto,
                         CryptoParams* out) {
   for (CryptoParamsVec::const_iterator it = cryptos.begin();
        it != cryptos.end(); ++it) {
     if (crypto.Matches(*it)) {
       *out = *it;
       return true;
     }
   }
   return false;
 }
 
 // For audio, HMAC 32 is prefered over HMAC 80 because of the low overhead.
 void GetSupportedAudioCryptoSuites(const rtc::CryptoOptions& crypto_options,
     std::vector<int>* crypto_suites) {
-#ifdef HAVE_SRTP
   if (crypto_options.enable_gcm_crypto_suites) {
     crypto_suites->push_back(rtc::SRTP_AEAD_AES_256_GCM);
     crypto_suites->push_back(rtc::SRTP_AEAD_AES_128_GCM);
   }
   crypto_suites->push_back(rtc::SRTP_AES128_CM_SHA1_32);
   crypto_suites->push_back(rtc::SRTP_AES128_CM_SHA1_80);
-#endif
 }
 
 void GetSupportedAudioCryptoSuiteNames(const rtc::CryptoOptions& crypto_options,
     std::vector<std::string>* crypto_suite_names) {
   GetSupportedCryptoSuiteNames(GetSupportedAudioCryptoSuites,
                                crypto_options, crypto_suite_names);
 }
 
 void GetSupportedVideoCryptoSuites(const rtc::CryptoOptions& crypto_options,
     std::vector<int>* crypto_suites) {
@@ skipping 12 matching lines @@
 }
 
 void GetSupportedDataCryptoSuiteNames(const rtc::CryptoOptions& crypto_options,
     std::vector<std::string>* crypto_suite_names) {
   GetSupportedCryptoSuiteNames(GetSupportedDataCryptoSuites,
                                crypto_options, crypto_suite_names);
 }
 
 void GetDefaultSrtpCryptoSuites(const rtc::CryptoOptions& crypto_options,
     std::vector<int>* crypto_suites) {
-#ifdef HAVE_SRTP
   if (crypto_options.enable_gcm_crypto_suites) {
     crypto_suites->push_back(rtc::SRTP_AEAD_AES_256_GCM);
     crypto_suites->push_back(rtc::SRTP_AEAD_AES_128_GCM);
   }
   crypto_suites->push_back(rtc::SRTP_AES128_CM_SHA1_80);
-#endif
 }
 
 void GetDefaultSrtpCryptoSuiteNames(const rtc::CryptoOptions& crypto_options,
     std::vector<std::string>* crypto_suite_names) {
   GetSupportedCryptoSuiteNames(GetDefaultSrtpCryptoSuites,
                                crypto_options, crypto_suite_names);
 }
 
 // Support any GCM cipher (if enabled through options). For video support only
 // 80-bit SHA1 HMAC. For audio 32-bit HMAC is tolerated unless bundle is enabled
@@ skipping 510 matching lines @@
     offer->set_rtcp_reduced_size(true);
   }
   offer->set_multistream(options.is_muc);
   offer->set_rtp_header_extensions(rtp_extensions);
 
   if (!AddStreamParams(offer->type(), options, current_streams, offer,
                        add_legacy_stream)) {
     return false;
   }
 
-#ifdef HAVE_SRTP
   if (secure_policy != SEC_DISABLED) {
     if (current_cryptos) {
       AddMediaCryptos(*current_cryptos, offer);
     }
     if (offer->cryptos().empty()) {
       if (!CreateMediaCryptos(crypto_suites, offer)) {
         return false;
       }
     }
   }
-#endif
 
   if (secure_policy == SEC_REQUIRED && offer->cryptos().empty()) {
     return false;
   }
   return true;
 }
 
 template <class C>
 static bool ReferencedCodecsMatch(const std::vector<C>& codecs1,
                                   const int codec1_id,
@@ skipping 1406 matching lines @@
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_VIDEO));
 }
 
 DataContentDescription* GetFirstDataContentDescription(
     SessionDescription* sdesc) {
   return static_cast<DataContentDescription*>(
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_DATA));
 }
 
 }  // namespace cricket