text: /*
   *  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.
   */
  
  #include "webrtc/pc/mediasession.h"
  
  #include <algorithm>  // For std::find_if, std::sort.
  #include <functional>
  #include <map>
  #include <memory>
  #include <set>
  #include <unordered_map>
  #include <utility>
  
  #include "webrtc/base/helpers.h"
  #include "webrtc/base/logging.h"
  #include "webrtc/base/stringutils.h"
  #include "webrtc/media/base/cryptoparams.h"
  #include "webrtc/media/base/mediaconstants.h"
  #include "webrtc/p2p/base/p2pconstants.h"
  #include "webrtc/pc/channelmanager.h"
  #include "webrtc/pc/srtpfilter.h"
  
  #ifdef HAVE_SCTP
  #include "webrtc/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
  
  namespace cricket {
  
  // RTP Profile names
  // http://www.iana.org/assignments/rtp-parameters/rtp-parameters.xml
  // RFC4585
  const char kMediaProtocolAvpf[] = "RTP/AVPF";
  // RFC5124
  const char kMediaProtocolDtlsSavpf[] = "UDP/TLS/RTP/SAVPF";
  
  // We always generate offers with "UDP/TLS/RTP/SAVPF" when using DTLS-SRTP,
  // but we tolerate "RTP/SAVPF" in offers we receive, for compatibility.
  const char kMediaProtocolSavpf[] = "RTP/SAVPF";
  
  const char kMediaProtocolRtpPrefix[] = "RTP/";
  
  const char kMediaProtocolSctp[] = "SCTP";
  const char kMediaProtocolDtlsSctp[] = "DTLS/SCTP";
  const char kMediaProtocolUdpDtlsSctp[] = "UDP/DTLS/SCTP";
  const char kMediaProtocolTcpDtlsSctp[] = "TCP/DTLS/SCTP";
  
  RtpTransceiverDirection RtpTransceiverDirection::FromMediaContentDirection(
      MediaContentDirection md) {
    const bool send = (md == MD_SENDRECV || md == MD_SENDONLY);
    const bool recv = (md == MD_SENDRECV || md == MD_RECVONLY);
    return RtpTransceiverDirection(send, recv);
  }
  
  MediaContentDirection RtpTransceiverDirection::ToMediaContentDirection() const {
    if (send && recv) {
      return MD_SENDRECV;
    } else if (send) {
      return MD_SENDONLY;
    } else if (recv) {
      return MD_RECVONLY;
    }
  
    return MD_INACTIVE;
  }
  
  RtpTransceiverDirection
  NegotiateRtpTransceiverDirection(RtpTransceiverDirection offer,
                                   RtpTransceiverDirection wants) {
    return RtpTransceiverDirection(offer.recv && wants.send,
                                   offer.send && wants.recv);
  }
  
  static bool IsMediaContentOfType(const ContentInfo* content,
                                   MediaType media_type) {
    if (!IsMediaContent(content)) {
      return false;
    }
  
    const MediaContentDescription* mdesc =
        static_cast<const MediaContentDescription*>(content->description);
    return mdesc && mdesc->type() == media_type;
  }
  
  static bool CreateCryptoParams(int tag, const std::string& cipher,
                                 CryptoParams *out) {
    std::string key;
    key.reserve(SRTP_MASTER_KEY_BASE64_LEN);
  
    if (!rtc::CreateRandomString(SRTP_MASTER_KEY_BASE64_LEN, &key)) {
      return false;
    }
    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 because of the low overhead.
  void GetSupportedAudioCryptoSuites(std::vector<int>* crypto_suites) {
  #ifdef HAVE_SRTP
    crypto_suites->push_back(rtc::SRTP_AES128_CM_SHA1_32);
    crypto_suites->push_back(rtc::SRTP_AES128_CM_SHA1_80);
  #endif
  }
  
  void GetSupportedAudioCryptoSuiteNames(
      std::vector<std::string>* crypto_suite_names) {
    GetSupportedCryptoSuiteNames(GetSupportedAudioCryptoSuites,
                                 crypto_suite_names);
  }
  
  void GetSupportedVideoCryptoSuites(std::vector<int>* crypto_suites) {
    GetDefaultSrtpCryptoSuites(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::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();
         i != cryptos.end(); ++i) {
      if (rtc::CS_AES_CM_128_HMAC_SHA1_80 == i->cipher_suite ||
          (rtc::CS_AES_CM_128_HMAC_SHA1_32 == i->cipher_suite && audio &&
           !bundle)) {
        return CreateCryptoParams(i->tag, i->cipher_suite, crypto);
      }
    }
    return false;
  }
  
  // Generate random SSRC values that are not already present in |params_vec|.
  // The generated values are added to |ssrcs|.
  // |num_ssrcs| is the number of the SSRC will be generated.
  static void GenerateSsrcs(const StreamParamsVec& params_vec,
                            int num_ssrcs,
                            std::vector<uint32_t>* ssrcs) {
    for (int i = 0; i < num_ssrcs; i++) {
      uint32_t candidate;
      do {
        candidate = rtc::CreateRandomNonZeroId();
      } while (GetStreamBySsrc(params_vec, candidate) ||
               std::count(ssrcs->begin(), ssrcs->end(), candidate) > 0);
      ssrcs->push_back(candidate);
    }
  }
  
  // Returns false if we exhaust the range of SIDs.
  static bool GenerateSctpSid(const StreamParamsVec& params_vec, uint32_t* sid) {
    if (params_vec.size() > kMaxSctpSid) {
      LOG(LS_WARNING) <<
          "Could not generate an SCTP SID: too many SCTP streams.";
      return false;
    }
    while (true) {
      uint32_t candidate = rtc::CreateRandomNonZeroId() % kMaxSctpSid;
      if (!GetStreamBySsrc(params_vec, candidate)) {
        *sid = candidate;
        return true;
      }
    }
  }
  
  static bool GenerateSctpSids(const StreamParamsVec& params_vec,
                               std::vector<uint32_t>* sids) {
    uint32_t sid;
    if (!GenerateSctpSid(params_vec, &sid)) {
      LOG(LS_WARNING) << "Could not generated an SCTP SID.";
      return false;
    }
    sids->push_back(sid);
    return true;
  }
  
  // Finds all StreamParams of all media types and attach them to stream_params.
  static void GetCurrentStreamParams(const SessionDescription* sdesc,
                                     StreamParamsVec* stream_params) {
    if (!sdesc)
      return;
  
    const ContentInfos& contents = sdesc->contents();
    for (ContentInfos::const_iterator content = contents.begin();
         content != contents.end(); ++content) {
      if (!IsMediaContent(&*content)) {
        continue;
      }
      const MediaContentDescription* media =
          static_cast<const MediaContentDescription*>(
              content->description);
      const StreamParamsVec& streams = media->streams();
      for (StreamParamsVec::const_iterator it = streams.begin();
           it != streams.end(); ++it) {
        stream_params->push_back(*it);
      }
    }
  }
  
  // Filters the data codecs for the data channel type.
  void FilterDataCodecs(std::vector<DataCodec>* codecs, bool sctp) {
    // Filter RTP codec for SCTP and vice versa.
    int codec_id = sctp ? kGoogleRtpDataCodecId : kGoogleSctpDataCodecId;
    for (std::vector<DataCodec>::iterator iter = codecs->begin();
         iter != codecs->end();) {
      if (iter->id == codec_id) {
        iter = codecs->erase(iter);
      } else {
        ++iter;
      }
    }
  }
  
  template <typename IdStruct>
  class UsedIds {
   public:
    UsedIds(int min_allowed_id, int max_allowed_id)
        : min_allowed_id_(min_allowed_id),
          max_allowed_id_(max_allowed_id),
          next_id_(max_allowed_id) {
    }
  
    // Loops through all Id in |ids| and changes its id if it is
    // already in use by another IdStruct. Call this methods with all Id
    // in a session description to make sure no duplicate ids exists.
    // Note that typename Id must be a type of IdStruct.
    template <typename Id>
    void FindAndSetIdUsed(std::vector<Id>* ids) {
      for (typename std::vector<Id>::iterator it = ids->begin();
           it != ids->end(); ++it) {
        FindAndSetIdUsed(&*it);
      }
    }
  
    // Finds and sets an unused id if the |idstruct| id is already in use.
    void FindAndSetIdUsed(IdStruct* idstruct) {
      const int original_id = idstruct->id;
      int new_id = idstruct->id;
  
      if (original_id > max_allowed_id_ || original_id < min_allowed_id_) {
        // If the original id is not in range - this is an id that can't be
        // dynamically changed.
        return;
      }
  
      if (IsIdUsed(original_id)) {
        new_id = FindUnusedId();
        LOG(LS_WARNING) << "Duplicate id found. Reassigning from " << original_id
            << " to " << new_id;
        idstruct->id = new_id;
      }
      SetIdUsed(new_id);
    }
  
   private:
    // Returns the first unused id in reverse order.
    // This hopefully reduce the risk of more collisions. We want to change the
    // default ids as little as possible.
    int FindUnusedId() {
      while (IsIdUsed(next_id_) && next_id_ >= min_allowed_id_) {
        --next_id_;
      }
      ASSERT(next_id_ >= min_allowed_id_);
      return next_id_;
    }
  
    bool IsIdUsed(int new_id) {
      return id_set_.find(new_id) != id_set_.end();
    }
  
    void SetIdUsed(int new_id) {
      id_set_.insert(new_id);
    }
  
    const int min_allowed_id_;
    const int max_allowed_id_;
    int next_id_;
    std::set<int> id_set_;
  };
  
  // Helper class used for finding duplicate RTP payload types among audio, video
  // and data codecs. When bundle is used the payload types may not collide.
  class UsedPayloadTypes : public UsedIds<Codec> {
   public:
    UsedPayloadTypes()
        : UsedIds<Codec>(kDynamicPayloadTypeMin, kDynamicPayloadTypeMax) {
    }
  
  
   private:
    static const int kDynamicPayloadTypeMin = 96;
    static const int kDynamicPayloadTypeMax = 127;
  };
  
  // Helper class used for finding duplicate RTP Header extension ids among
  // audio and video extensions.
  class UsedRtpHeaderExtensionIds : public UsedIds<webrtc::RtpExtension> {
   public:
    UsedRtpHeaderExtensionIds()
        : UsedIds<webrtc::RtpExtension>(kLocalIdMin, kLocalIdMax) {}
  
   private:
    // Min and Max local identifier for one-byte header extensions, per RFC5285.
    static const int kLocalIdMin = 1;
    static const int kLocalIdMax = 14;
  };
  
  static bool IsSctp(const MediaContentDescription* desc) {
    return ((desc->protocol() == kMediaProtocolSctp) ||
            (desc->protocol() == kMediaProtocolDtlsSctp));
  }
  
  // Adds a StreamParams for each Stream in Streams with media type
  // media_type to content_description.
  // |current_params| - All currently known StreamParams of any media type.
  template <class C>
  static bool AddStreamParams(MediaType media_type,
                              const MediaSessionOptions& options,
                              StreamParamsVec* current_streams,
                              MediaContentDescriptionImpl<C>* content_description,
                              const bool add_legacy_stream) {
    const bool include_rtx_streams =
        ContainsRtxCodec(content_description->codecs());
  
    const MediaSessionOptions::Streams& streams = options.streams;
    if (streams.empty() && add_legacy_stream) {
      // TODO(perkj): Remove this legacy stream when all apps use StreamParams.
      std::vector<uint32_t> ssrcs;
      if (IsSctp(content_description)) {
        GenerateSctpSids(*current_streams, &ssrcs);
      } else {
        int num_ssrcs = include_rtx_streams ? 2 : 1;
        GenerateSsrcs(*current_streams, num_ssrcs, &ssrcs);
      }
      if (include_rtx_streams) {
        content_description->AddLegacyStream(ssrcs[0], ssrcs[1]);
        content_description->set_multistream(true);
      } else {
        content_description->AddLegacyStream(ssrcs[0]);
      }
      return true;
    }
  
    MediaSessionOptions::Streams::const_iterator stream_it;
    for (stream_it = streams.begin();
         stream_it != streams.end(); ++stream_it) {
      if (stream_it->type != media_type)
        continue;  // Wrong media type.
  
      const StreamParams* param =
          GetStreamByIds(*current_streams, "", stream_it->id);
      // groupid is empty for StreamParams generated using
      // MediaSessionDescriptionFactory.
      if (!param) {
        // This is a new stream.
        std::vector<uint32_t> ssrcs;
        if (IsSctp(content_description)) {
          GenerateSctpSids(*current_streams, &ssrcs);
        } else {
          GenerateSsrcs(*current_streams, stream_it->num_sim_layers, &ssrcs);
        }
        StreamParams stream_param;
        stream_param.id = stream_it->id;
        // Add the generated ssrc.
        for (size_t i = 0; i < ssrcs.size(); ++i) {
          stream_param.ssrcs.push_back(ssrcs[i]);
        }
        if (stream_it->num_sim_layers > 1) {
          SsrcGroup group(kSimSsrcGroupSemantics, stream_param.ssrcs);
          stream_param.ssrc_groups.push_back(group);
        }
        // Generate extra ssrcs for include_rtx_streams case.
        if (include_rtx_streams) {
          // Generate an RTX ssrc for every ssrc in the group.
          std::vector<uint32_t> rtx_ssrcs;
          GenerateSsrcs(*current_streams, static_cast<int>(ssrcs.size()),
                        &rtx_ssrcs);
          for (size_t i = 0; i < ssrcs.size(); ++i) {
            stream_param.AddFidSsrc(ssrcs[i], rtx_ssrcs[i]);
          }
          content_description->set_multistream(true);
        }
        stream_param.cname = options.rtcp_cname;
        stream_param.sync_label = stream_it->sync_label;
        content_description->AddStream(stream_param);
  
        // Store the new StreamParams in current_streams.
        // This is necessary so that we can use the CNAME for other media types.
        current_streams->push_back(stream_param);
      } else {
        content_description->AddStream(*param);
      }
    }
    return true;
  }
  
  // Updates the transport infos of the |sdesc| according to the given
  // |bundle_group|. The transport infos of the content names within the
  // |bundle_group| should be updated to use the ufrag, pwd and DTLS role of the
  // first content within the |bundle_group|.
  static bool UpdateTransportInfoForBundle(const ContentGroup& bundle_group,
                                           SessionDescription* sdesc) {
    // The bundle should not be empty.
    if (!sdesc || !bundle_group.FirstContentName()) {
      return false;
    }
  
    // We should definitely have a transport for the first content.
    const std::string& selected_content_name = *bundle_group.FirstContentName();
    const TransportInfo* selected_transport_info =
        sdesc->GetTransportInfoByName(selected_content_name);
    if (!selected_transport_info) {
      return false;
    }
  
    // Set the other contents to use the same ICE credentials.
    const std::string& selected_ufrag =
        selected_transport_info->description.ice_ufrag;
    const std::string& selected_pwd =
        selected_transport_info->description.ice_pwd;
    ConnectionRole selected_connection_role =
        selected_transport_info->description.connection_role;
    for (TransportInfos::iterator it =
             sdesc->transport_infos().begin();
         it != sdesc->transport_infos().end(); ++it) {
      if (bundle_group.HasContentName(it->content_name) &&
          it->content_name != selected_content_name) {
        it->description.ice_ufrag = selected_ufrag;
        it->description.ice_pwd = selected_pwd;
        it->description.connection_role = selected_connection_role;
      }
    }
    return true;
  }
  
  // Gets the CryptoParamsVec of the given |content_name| from |sdesc|, and
  // sets it to |cryptos|.
  static bool GetCryptosByName(const SessionDescription* sdesc,
                               const std::string& content_name,
                               CryptoParamsVec* cryptos) {
    if (!sdesc || !cryptos) {
      return false;
    }
  
    const ContentInfo* content = sdesc->GetContentByName(content_name);
    if (!IsMediaContent(content) || !content->description) {
      return false;
    }
  
    const MediaContentDescription* media_desc =
        static_cast<const MediaContentDescription*>(content->description);
    *cryptos = media_desc->cryptos();
    return true;
  }
  
  // Predicate function used by the remove_if.
  // Returns true if the |crypto|'s cipher_suite is not found in |filter|.
  static bool CryptoNotFound(const CryptoParams crypto,
                             const CryptoParamsVec* filter) {
    if (filter == NULL) {
      return true;
    }
    for (CryptoParamsVec::const_iterator it = filter->begin();
         it != filter->end(); ++it) {
      if (it->cipher_suite == crypto.cipher_suite) {
        return false;
      }
    }
    return true;
  }
  
  // Prunes the |target_cryptos| by removing the crypto params (cipher_suite)
  // which are not available in |filter|.
  static void PruneCryptos(const CryptoParamsVec& filter,
                           CryptoParamsVec* target_cryptos) {
    if (!target_cryptos) {
      return;
    }
    target_cryptos->erase(std::remove_if(target_cryptos->begin(),
                                         target_cryptos->end(),
                                         bind2nd(ptr_fun(CryptoNotFound),
                                                 &filter)),
                          target_cryptos->end());
  }
  
  static bool IsRtpProtocol(const std::string& protocol) {
    return protocol.empty() ||
           (protocol.find(cricket::kMediaProtocolRtpPrefix) != std::string::npos);
  }
  
  static bool IsRtpContent(SessionDescription* sdesc,
                           const std::string& content_name) {
    bool is_rtp = false;
    ContentInfo* content = sdesc->GetContentByName(content_name);
    if (IsMediaContent(content)) {
      MediaContentDescription* media_desc =
          static_cast<MediaContentDescription*>(content->description);
      if (!media_desc) {
        return false;
      }
      is_rtp = IsRtpProtocol(media_desc->protocol());
    }
    return is_rtp;
  }
  
  // Updates the crypto parameters of the |sdesc| according to the given
  // |bundle_group|. The crypto parameters of all the contents within the
  // |bundle_group| should be updated to use the common subset of the
  // available cryptos.
  static bool UpdateCryptoParamsForBundle(const ContentGroup& bundle_group,
                                          SessionDescription* sdesc) {
    // The bundle should not be empty.
    if (!sdesc || !bundle_group.FirstContentName()) {
      return false;
    }
  
    bool common_cryptos_needed = false;
    // Get the common cryptos.
    const ContentNames& content_names = bundle_group.content_names();
    CryptoParamsVec common_cryptos;
    for (ContentNames::const_iterator it = content_names.begin();
         it != content_names.end(); ++it) {
      if (!IsRtpContent(sdesc, *it)) {
        continue;
      }
      // The common cryptos are needed if any of the content does not have DTLS
      // enabled.
      if (!sdesc->GetTransportInfoByName(*it)->description.secure()) {
        common_cryptos_needed = true;
      }
      if (it == content_names.begin()) {
        // Initial the common_cryptos with the first content in the bundle group.
        if (!GetCryptosByName(sdesc, *it, &common_cryptos)) {
          return false;
        }
        if (common_cryptos.empty()) {
          // If there's no crypto params, we should just return.
          return true;
        }
      } else {
        CryptoParamsVec cryptos;
        if (!GetCryptosByName(sdesc, *it, &cryptos)) {
          return false;
        }
        PruneCryptos(cryptos, &common_cryptos);
      }
    }
  
    if (common_cryptos.empty() && common_cryptos_needed) {
      return false;
    }
  
    // Update to use the common cryptos.
    for (ContentNames::const_iterator it = content_names.begin();
         it != content_names.end(); ++it) {
      if (!IsRtpContent(sdesc, *it)) {
        continue;
      }
      ContentInfo* content = sdesc->GetContentByName(*it);
      if (IsMediaContent(content)) {
        MediaContentDescription* media_desc =
            static_cast<MediaContentDescription*>(content->description);
        if (!media_desc) {
          return false;
        }
        media_desc->set_cryptos(common_cryptos);
      }
    }
    return true;
  }
  
  template <class C>
  static bool ContainsRtxCodec(const std::vector<C>& codecs) {
    typename std::vector<C>::const_iterator it;
    for (it = codecs.begin(); it != codecs.end(); ++it) {
      if (IsRtxCodec(*it)) {
        return true;
      }
    }
    return false;
  }
  
  template <class C>
  static bool IsRtxCodec(const C& codec) {
    return stricmp(codec.name.c_str(), kRtxCodecName) == 0;
  }
  
  static TransportOptions GetTransportOptions(const MediaSessionOptions& options,
                                              const std::string& content_name) {
    auto it = options.transport_options.find(content_name);
    if (it == options.transport_options.end()) {
      return TransportOptions();
    }
    return it->second;
  }
  
  // Create a media content to be offered in a session-initiate,
  // according to the given options.rtcp_mux, options.is_muc,
  // options.streams, codecs, secure_transport, crypto, and streams.  If we don't
  // currently have crypto (in current_cryptos) and it is enabled (in
  // secure_policy), crypto is created (according to crypto_suites).  If
  // add_legacy_stream is true, and current_streams is empty, a legacy
  // stream is created.  The created content is added to the offer.
  template <class C>
  static bool CreateMediaContentOffer(
      const MediaSessionOptions& options,
      const std::vector<C>& codecs,
      const SecurePolicy& secure_policy,
      const CryptoParamsVec* current_cryptos,
      const std::vector<std::string>& crypto_suites,
      const RtpHeaderExtensions& rtp_extensions,
      bool add_legacy_stream,
      StreamParamsVec* current_streams,
      MediaContentDescriptionImpl<C>* offer) {
    offer->AddCodecs(codecs);
  
    if (secure_policy == SEC_REQUIRED) {
      offer->set_crypto_required(CT_SDES);
    }
    offer->set_rtcp_mux(options.rtcp_mux_enabled);
    if (offer->type() == cricket::MEDIA_TYPE_VIDEO) {
      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 (offer->crypto_required() == CT_SDES && offer->cryptos().empty()) {
      return false;
    }
    return true;
  }
  
  template <class C>
  static bool ReferencedCodecsMatch(const std::vector<C>& codecs1,
                                    const std::string& codec1_id_str,
                                    const std::vector<C>& codecs2,
                                    const std::string& codec2_id_str) {
    int codec1_id;
    int codec2_id;
    C codec1;
    C codec2;
    if (!rtc::FromString(codec1_id_str, &codec1_id) ||
        !rtc::FromString(codec2_id_str, &codec2_id) ||
        !FindCodecById(codecs1, codec1_id, &codec1) ||
        !FindCodecById(codecs2, codec2_id, &codec2)) {
      return false;
    }
    return codec1.Matches(codec2);
  }
  
  template <class C>
  static void NegotiateCodecs(const std::vector<C>& local_codecs,
                              const std::vector<C>& offered_codecs,
                              std::vector<C>* negotiated_codecs) {
    for (const C& ours : local_codecs) {
      C theirs;
      // Note that we intentionally only find one matching codec for each of our
      // local codecs, in case the remote offer contains duplicate codecs.
      if (FindMatchingCodec(local_codecs, offered_codecs, ours, &theirs)) {
        C negotiated = ours;
        negotiated.IntersectFeedbackParams(theirs);
        if (IsRtxCodec(negotiated)) {
          std::string offered_apt_value;
          theirs.GetParam(kCodecParamAssociatedPayloadType, &offered_apt_value);
          // FindMatchingCodec shouldn't return something with no apt value.
          RTC_DCHECK(!offered_apt_value.empty());
          negotiated.SetParam(kCodecParamAssociatedPayloadType,
                              offered_apt_value);
        }
        negotiated.id = theirs.id;
        negotiated.name = theirs.name;
        negotiated_codecs->push_back(negotiated);
      }
    }
    // RFC3264: Although the answerer MAY list the formats in their desired
    // order of preference, it is RECOMMENDED that unless there is a
    // specific reason, the answerer list formats in the same relative order
    // they were present in the offer.
    std::unordered_map<int, int> payload_type_preferences;
    int preference = static_cast<int>(offered_codecs.size() + 1);
    for (const C& codec : offered_codecs) {
      payload_type_preferences[codec.id] = preference--;
    }
    std::sort(negotiated_codecs->begin(), negotiated_codecs->end(),
              [&payload_type_preferences](const C& a, const C& b) {
                return payload_type_preferences[a.id] >
                       payload_type_preferences[b.id];
              });
  }
  
  // Finds a codec in |codecs2| that matches |codec_to_match|, which is
  // a member of |codecs1|. If |codec_to_match| is an RTX codec, both
  // the codecs themselves and their associated codecs must match.
  template <class C>
  static bool FindMatchingCodec(const std::vector<C>& codecs1,
                                const std::vector<C>& codecs2,
                                const C& codec_to_match,
                                C* found_codec) {
    for (const C& potential_match : codecs2) {
      if (potential_match.Matches(codec_to_match)) {
        if (IsRtxCodec(codec_to_match)) {
          std::string apt_value_1;
          std::string apt_value_2;
          if (!codec_to_match.GetParam(kCodecParamAssociatedPayloadType,
                                       &apt_value_1) ||
              !potential_match.GetParam(kCodecParamAssociatedPayloadType,
                                        &apt_value_2)) {
            LOG(LS_WARNING) << "RTX missing associated payload type.";
            continue;
          }
          if (!ReferencedCodecsMatch(codecs1, apt_value_1, codecs2,
                                     apt_value_2)) {
            continue;
          }
        }
        if (found_codec) {
          *found_codec = potential_match;
        }
        return true;
      }
    }
    return false;
  }
  
  // Adds all codecs from |reference_codecs| to |offered_codecs| that dont'
  // already exist in |offered_codecs| and ensure the payload types don't
  // collide.
  template <class C>
  static void FindCodecsToOffer(
      const std::vector<C>& reference_codecs,
      std::vector<C>* offered_codecs,
      UsedPayloadTypes* used_pltypes) {
  
    // Add all new codecs that are not RTX codecs.
    for (const C& reference_codec : reference_codecs) {
      if (!IsRtxCodec(reference_codec) &&
          !FindMatchingCodec<C>(reference_codecs, *offered_codecs,
                                reference_codec, nullptr)) {
        C codec = reference_codec;
        used_pltypes->FindAndSetIdUsed(&codec);
        offered_codecs->push_back(codec);
      }
    }
  
    // Add all new RTX codecs.
    for (const C& reference_codec : reference_codecs) {
      if (IsRtxCodec(reference_codec) &&
          !FindMatchingCodec<C>(reference_codecs, *offered_codecs,
                                reference_codec, nullptr)) {
        C rtx_codec = reference_codec;
  
        std::string associated_pt_str;
        if (!rtx_codec.GetParam(kCodecParamAssociatedPayloadType,
                                &associated_pt_str)) {
          LOG(LS_WARNING) << "RTX codec " << rtx_codec.name
                          << " is missing an associated payload type.";
          continue;
        }
  
        int associated_pt;
        if (!rtc::FromString(associated_pt_str, &associated_pt)) {
          LOG(LS_WARNING) << "Couldn't convert payload type " << associated_pt_str
                          << " of RTX codec " << rtx_codec.name
                          << " to an integer.";
          continue;
        }
  
        // Find the associated reference codec for the reference RTX codec.
        C associated_codec;
        if (!FindCodecById(reference_codecs, associated_pt, &associated_codec)) {
          LOG(LS_WARNING) << "Couldn't find associated codec with payload type "
                          << associated_pt << " for RTX codec " << rtx_codec.name
                          << ".";
          continue;
        }
  
        // Find a codec in the offered list that matches the reference codec.
        // Its payload type may be different than the reference codec.
        C matching_codec;
        if (!FindMatchingCodec<C>(reference_codecs, *offered_codecs,
                                 associated_codec, &matching_codec)) {
          LOG(LS_WARNING) << "Couldn't find matching " << associated_codec.name
                          << " codec.";
          continue;
        }
  
        rtx_codec.params[kCodecParamAssociatedPayloadType] =
            rtc::ToString(matching_codec.id);
        used_pltypes->FindAndSetIdUsed(&rtx_codec);
        offered_codecs->push_back(rtx_codec);
      }
    }
  }
  
  static bool FindByUri(const RtpHeaderExtensions& extensions,
                        const webrtc::RtpExtension& ext_to_match,
                        webrtc::RtpExtension* found_extension) {
    for (RtpHeaderExtensions::const_iterator it = extensions.begin();
         it  != extensions.end(); ++it) {
      // We assume that all URIs are given in a canonical format.
      if (it->uri == ext_to_match.uri) {
        if (found_extension != NULL) {
          *found_extension = *it;
        }
        return true;
      }
    }
    return false;
  }
  
  // Iterates through |offered_extensions|, adding each one to |all_extensions|
  // and |used_ids|, and resolving ID conflicts. If an offered extension has the
  // same URI as one in |all_extensions|, it will re-use the same ID and won't be
  // treated as a conflict.
  static void FindAndSetRtpHdrExtUsed(RtpHeaderExtensions* offered_extensions,
                                      RtpHeaderExtensions* all_extensions,
                                      UsedRtpHeaderExtensionIds* used_ids) {
    for (auto& extension : *offered_extensions) {
      webrtc::RtpExtension existing;
      if (FindByUri(*all_extensions, extension, &existing)) {
        extension.id = existing.id;
      } else {
        used_ids->FindAndSetIdUsed(&extension);
        all_extensions->push_back(extension);
      }
    }
  }
  
  // Adds |reference_extensions| to |offered_extensions|, while updating
  // |all_extensions| and |used_ids|.
  static void FindRtpHdrExtsToOffer(
      const RtpHeaderExtensions& reference_extensions,
      RtpHeaderExtensions* offered_extensions,
      RtpHeaderExtensions* all_extensions,
      UsedRtpHeaderExtensionIds* used_ids) {
    for (auto reference_extension : reference_extensions) {
      if (!FindByUri(*offered_extensions, reference_extension, NULL)) {
        webrtc::RtpExtension existing;
        if (FindByUri(*all_extensions, reference_extension, &existing)) {
          offered_extensions->push_back(existing);
        } else {
          used_ids->FindAndSetIdUsed(&reference_extension);
          all_extensions->push_back(reference_extension);
          offered_extensions->push_back(reference_extension);
        }
      }
    }
  }
  
  static void NegotiateRtpHeaderExtensions(
      const RtpHeaderExtensions& local_extensions,
      const RtpHeaderExtensions& offered_extensions,
      RtpHeaderExtensions* negotiated_extenstions) {
    RtpHeaderExtensions::const_iterator ours;
    for (ours = local_extensions.begin();
         ours != local_extensions.end(); ++ours) {
      webrtc::RtpExtension theirs;
      if (FindByUri(offered_extensions, *ours, &theirs)) {
        // We respond with their RTP header extension id.
        negotiated_extenstions->push_back(theirs);
      }
    }
  }
  
  static void StripCNCodecs(AudioCodecs* audio_codecs) {
    AudioCodecs::iterator iter = audio_codecs->begin();
    while (iter != audio_codecs->end()) {
      if (stricmp(iter->name.c_str(), kComfortNoiseCodecName) == 0) {
        iter = audio_codecs->erase(iter);
      } else {
        ++iter;
      }
    }
  }
  
  // Create a media content to be answered in a session-accept,
  // according to the given options.rtcp_mux, options.streams, codecs,
  // crypto, and streams.  If we don't currently have crypto (in
  // current_cryptos) and it is enabled (in secure_policy), crypto is
  // created (according to crypto_suites).  If add_legacy_stream is
  // true, and current_streams is empty, a legacy stream is created.
  // The codecs, rtcp_mux, and crypto are all negotiated with the offer
  // from the incoming session-initiate.  If the negotiation fails, this
  // method returns false.  The created content is added to the offer.
  template <class C>
  static bool CreateMediaContentAnswer(
      const MediaContentDescriptionImpl<C>* offer,
      const MediaSessionOptions& options,
      const std::vector<C>& local_codecs,
      const SecurePolicy& sdes_policy,
      const CryptoParamsVec* current_cryptos,
      const RtpHeaderExtensions& local_rtp_extenstions,
      StreamParamsVec* current_streams,
      bool add_legacy_stream,
      bool bundle_enabled,
      MediaContentDescriptionImpl<C>* answer) {
    std::vector<C> negotiated_codecs;
    NegotiateCodecs(local_codecs, offer->codecs(), &negotiated_codecs);
    answer->AddCodecs(negotiated_codecs);
    answer->set_protocol(offer->protocol());
    RtpHeaderExtensions negotiated_rtp_extensions;
    NegotiateRtpHeaderExtensions(local_rtp_extenstions,
                                 offer->rtp_header_extensions(),
                                 &negotiated_rtp_extensions);
    answer->set_rtp_header_extensions(negotiated_rtp_extensions);
  
    answer->set_rtcp_mux(options.rtcp_mux_enabled && offer->rtcp_mux());
    if (answer->type() == cricket::MEDIA_TYPE_VIDEO) {
      answer->set_rtcp_reduced_size(offer->rtcp_reduced_size());
    }
  
    if (sdes_policy != SEC_DISABLED) {
      CryptoParams crypto;
      if (SelectCrypto(offer, bundle_enabled, &crypto)) {
        if (current_cryptos) {
          FindMatchingCrypto(*current_cryptos, crypto, &crypto);
        }
        answer->AddCrypto(crypto);
      }
    }
  
    if (answer->cryptos().empty() &&
        (offer->crypto_required() == CT_SDES || sdes_policy == SEC_REQUIRED)) {
      return false;
    }
  
    if (!AddStreamParams(answer->type(), options, current_streams, answer,
                         add_legacy_stream)) {
      return false;  // Something went seriously wrong.
    }
  
    // Make sure the answer media content direction is per default set as
    // described in RFC3264 section 6.1.
    const bool is_data = !IsRtpProtocol(answer->protocol());
    const bool has_send_streams = !answer->streams().empty();
    const bool wants_send = has_send_streams || is_data;
    const bool recv_audio =
        answer->type() == cricket::MEDIA_TYPE_AUDIO && options.recv_audio;
    const bool recv_video =
        answer->type() == cricket::MEDIA_TYPE_VIDEO && options.recv_video;
    const bool recv_data =
        answer->type() == cricket::MEDIA_TYPE_DATA;
    const bool wants_receive = recv_audio || recv_video || recv_data;
  
    auto offer_rtd =
        RtpTransceiverDirection::FromMediaContentDirection(offer->direction());
    auto wants_rtd = RtpTransceiverDirection(wants_send, wants_receive);
    answer->set_direction(NegotiateRtpTransceiverDirection(offer_rtd, wants_rtd)
                          .ToMediaContentDirection());
    return true;
  }
  
  static bool IsDtlsRtp(const std::string& protocol) {
    // Most-likely values first.
    return protocol == "UDP/TLS/RTP/SAVPF" || protocol == "TCP/TLS/RTP/SAVPF" ||
           protocol == "UDP/TLS/RTP/SAVP" || protocol == "TCP/TLS/RTP/SAVP";
  }
  
  static bool IsPlainRtp(const std::string& protocol) {
    // Most-likely values first.
    return protocol == "RTP/SAVPF" || protocol == "RTP/AVPF" ||
           protocol == "RTP/SAVP" || protocol == "RTP/AVP";
  }
  
  static bool IsDtlsSctp(const std::string& protocol) {
    return protocol == "DTLS/SCTP";
  }
  
  static bool IsPlainSctp(const std::string& protocol) {
    return protocol == "SCTP";
  }
  
  static bool IsMediaProtocolSupported(MediaType type,
                                       const std::string& protocol,
                                       bool secure_transport) {
    // Since not all applications serialize and deserialize the media protocol,
    // we will have to accept |protocol| to be empty.
    if (protocol.empty()) {
      return true;
    }
  
    if (type == MEDIA_TYPE_DATA) {
      // Check for SCTP, but also for RTP for RTP-based data channels.
      // TODO(pthatcher): Remove RTP once RTP-based data channels are gone.
      if (secure_transport) {
        // Most likely scenarios first.
        return IsDtlsSctp(protocol) || IsDtlsRtp(protocol) ||
               IsPlainRtp(protocol);
      } else {
        return IsPlainSctp(protocol) || IsPlainRtp(protocol);
      }
    }
  
    // Allow for non-DTLS RTP protocol even when using DTLS because that's what
    // JSEP specifies.
    if (secure_transport) {
      // Most likely scenarios first.
      return IsDtlsRtp(protocol) || IsPlainRtp(protocol);
    } else {
      return IsPlainRtp(protocol);
    }
  }
  
  static void SetMediaProtocol(bool secure_transport,
                               MediaContentDescription* desc) {
    if (!desc->cryptos().empty())
      desc->set_protocol(kMediaProtocolSavpf);
    else if (secure_transport)
      desc->set_protocol(kMediaProtocolDtlsSavpf);
    else
      desc->set_protocol(kMediaProtocolAvpf);
  }
  
  // Gets the TransportInfo of the given |content_name| from the
  // |current_description|. If doesn't exist, returns a new one.
  static const TransportDescription* GetTransportDescription(
      const std::string& content_name,
      const SessionDescription* current_description) {
    const TransportDescription* desc = NULL;
    if (current_description) {
      const TransportInfo* info =
          current_description->GetTransportInfoByName(content_name);
      if (info) {
        desc = &info->description;
      }
    }
    return desc;
  }
  
  // Gets the current DTLS state from the transport description.
  static bool IsDtlsActive(
      const std::string& content_name,
      const SessionDescription* current_description) {
    if (!current_description)
      return false;
  
    const ContentInfo* content =
        current_description->GetContentByName(content_name);
    if (!content)
      return false;
  
    const TransportDescription* current_tdesc =
        GetTransportDescription(content_name, current_description);
    if (!current_tdesc)
      return false;
  
    return current_tdesc->secure();
  }
  
  std::string MediaTypeToString(MediaType type) {
    std::string type_str;
    switch (type) {
      case MEDIA_TYPE_AUDIO:
        type_str = "audio";
        break;
      case MEDIA_TYPE_VIDEO:
        type_str = "video";
        break;
      case MEDIA_TYPE_DATA:
        type_str = "data";
        break;
      default:
        ASSERT(false);
        break;
    }
    return type_str;
  }
  
  std::string MediaContentDirectionToString(MediaContentDirection direction) {
    std::string dir_str;
    switch (direction) {
      case MD_INACTIVE:
        dir_str = "inactive";
        break;
      case MD_SENDONLY:
        dir_str = "sendonly";
        break;
      case MD_RECVONLY:
        dir_str = "recvonly";
        break;
      case MD_SENDRECV:
        dir_str = "sendrecv";
        break;
      default:
        ASSERT(false);
        break;
    }
  
    return dir_str;
  }
  
  void MediaSessionOptions::AddSendStream(MediaType type,
                                      const std::string& id,
                                      const std::string& sync_label) {
    AddSendStreamInternal(type, id, sync_label, 1);
  }
  
  void MediaSessionOptions::AddSendVideoStream(
      const std::string& id,
      const std::string& sync_label,
      int num_sim_layers) {
    AddSendStreamInternal(MEDIA_TYPE_VIDEO, id, sync_label, num_sim_layers);
  }
  
  void MediaSessionOptions::AddSendStreamInternal(
      MediaType type,
      const std::string& id,
      const std::string& sync_label,
      int num_sim_layers) {
    streams.push_back(Stream(type, id, sync_label, num_sim_layers));
  
    // If we haven't already set the data_channel_type, and we add a
    // stream, we assume it's an RTP data stream.
    if (type == MEDIA_TYPE_DATA && data_channel_type == DCT_NONE)
      data_channel_type = DCT_RTP;
  }
  
  void MediaSessionOptions::RemoveSendStream(MediaType type,
                                         const std::string& id) {
    Streams::iterator stream_it = streams.begin();
    for (; stream_it != streams.end(); ++stream_it) {
      if (stream_it->type == type && stream_it->id == id) {
        streams.erase(stream_it);
        return;
      }
    }
    ASSERT(false);
  }
  
  bool MediaSessionOptions::HasSendMediaStream(MediaType type) const {
    Streams::const_iterator stream_it = streams.begin();
    for (; stream_it != streams.end(); ++stream_it) {
      if (stream_it->type == type) {
        return true;
      }
    }
    return false;
  }
  
  MediaSessionDescriptionFactory::MediaSessionDescriptionFactory(
      const TransportDescriptionFactory* transport_desc_factory)
      : secure_(SEC_DISABLED),
        add_legacy_(true),
        transport_desc_factory_(transport_desc_factory) {
  }
  
  MediaSessionDescriptionFactory::MediaSessionDescriptionFactory(
      ChannelManager* channel_manager,
      const TransportDescriptionFactory* transport_desc_factory)
      : secure_(SEC_DISABLED),
        add_legacy_(true),
        transport_desc_factory_(transport_desc_factory) {
    channel_manager->GetSupportedAudioSendCodecs(&audio_send_codecs_);
    channel_manager->GetSupportedAudioReceiveCodecs(&audio_recv_codecs_);
    channel_manager->GetSupportedAudioSendCodecs(&audio_send_codecs_);
    channel_manager->GetSupportedAudioRtpHeaderExtensions(&audio_rtp_extensions_);
    channel_manager->GetSupportedVideoCodecs(&video_codecs_);
    channel_manager->GetSupportedVideoRtpHeaderExtensions(&video_rtp_extensions_);
    channel_manager->GetSupportedDataCodecs(&data_codecs_);
    NegotiateCodecs(audio_recv_codecs_, audio_send_codecs_,
                    &audio_sendrecv_codecs_);
  }
  
  const AudioCodecs& MediaSessionDescriptionFactory::audio_sendrecv_codecs()
      const {
    return audio_sendrecv_codecs_;
  }
  
  const AudioCodecs& MediaSessionDescriptionFactory::audio_send_codecs() const {
    return audio_send_codecs_;
  }
  
  const AudioCodecs& MediaSessionDescriptionFactory::audio_recv_codecs() const {
    return audio_recv_codecs_;
  }
  
  void MediaSessionDescriptionFactory::set_audio_codecs(
      const AudioCodecs& send_codecs, const AudioCodecs& recv_codecs) {
    audio_send_codecs_ = send_codecs;
    audio_recv_codecs_ = recv_codecs;
    audio_sendrecv_codecs_.clear();
    // Use NegotiateCodecs to merge our codec lists, since the operation is
    // essentially the same. Put send_codecs as the offered_codecs, which is the
    // order we'd like to follow. The reasoning is that encoding is usually more
    // expensive than decoding, and prioritizing a codec in the send list probably
    // means it's a codec we can handle efficiently.
    NegotiateCodecs(recv_codecs, send_codecs, &audio_sendrecv_codecs_);
  }
  
  SessionDescription* MediaSessionDescriptionFactory::CreateOffer(
      const MediaSessionOptions& options,
      const SessionDescription* current_description) const {
    std::unique_ptr<SessionDescription> offer(new SessionDescription());
  
    StreamParamsVec current_streams;
    GetCurrentStreamParams(current_description, &current_streams);
  
    const bool wants_send =
        options.HasSendMediaStream(MEDIA_TYPE_AUDIO) || add_legacy_;
    const AudioCodecs& supported_audio_codecs =
        GetAudioCodecsForOffer({wants_send, options.recv_audio});
  
    AudioCodecs audio_codecs;
    VideoCodecs video_codecs;
    DataCodecs data_codecs;
    GetCodecsToOffer(current_description, supported_audio_codecs,
                     video_codecs_, data_codecs_,
                     &audio_codecs, &video_codecs, &data_codecs);
  
    if (!options.vad_enabled) {
      // If application doesn't want CN codecs in offer.
      StripCNCodecs(&audio_codecs);
    }
  
    RtpHeaderExtensions audio_rtp_extensions;
    RtpHeaderExtensions video_rtp_extensions;
    GetRtpHdrExtsToOffer(current_description, &audio_rtp_extensions,
                         &video_rtp_extensions);
  
    bool audio_added = false;
    bool video_added = false;
    bool data_added = false;
  
    // Iterate through the contents of |current_description| to maintain the order
    // of the m-lines in the new offer.
    if (current_description) {
      ContentInfos::const_iterator it = current_description->contents().begin();
      for (; it != current_description->contents().end(); ++it) {
        if (IsMediaContentOfType(&*it, MEDIA_TYPE_AUDIO)) {
          if (!AddAudioContentForOffer(options, current_description,
                                       audio_rtp_extensions, audio_codecs,
                                       &current_streams, offer.get())) {
            return NULL;
          }
          audio_added = true;
        } else if (IsMediaContentOfType(&*it, MEDIA_TYPE_VIDEO)) {
          if (!AddVideoContentForOffer(options, current_description,
                                       video_rtp_extensions, video_codecs,
                                       &current_streams, offer.get())) {
            return NULL;
          }
          video_added = true;
        } else if (IsMediaContentOfType(&*it, MEDIA_TYPE_DATA)) {
          MediaSessionOptions options_copy(options);
          if (IsSctp(static_cast<const MediaContentDescription*>(
                  it->description))) {
            options_copy.data_channel_type = DCT_SCTP;
          }
          if (!AddDataContentForOffer(options_copy, current_description,
                                      &data_codecs, &current_streams,
                                      offer.get())) {
            return NULL;
          }
          data_added = true;
        } else {
          ASSERT(false);
        }
      }
    }
  
    // Append contents that are not in |current_description|.
    if (!audio_added && options.has_audio() &&
        !AddAudioContentForOffer(options, current_description,
                                 audio_rtp_extensions, audio_codecs,
                                 &current_streams, offer.get())) {
      return NULL;
    }
    if (!video_added && options.has_video() &&
        !AddVideoContentForOffer(options, current_description,
                                 video_rtp_extensions, video_codecs,
                                 &current_streams, offer.get())) {
      return NULL;
    }
    if (!data_added && options.has_data() &&
        !AddDataContentForOffer(options, current_description, &data_codecs,
                                &current_streams, offer.get())) {
      return NULL;
    }
  
    // Bundle the contents together, if we've been asked to do so, and update any
    // parameters that need to be tweaked for BUNDLE.
    if (options.bundle_enabled) {
      ContentGroup offer_bundle(GROUP_TYPE_BUNDLE);
      for (ContentInfos::const_iterator content = offer->contents().begin();
         content != offer->contents().end(); ++content) {
        offer_bundle.AddContentName(content->name);
      }
      offer->AddGroup(offer_bundle);
      if (!UpdateTransportInfoForBundle(offer_bundle, offer.get())) {
        LOG(LS_ERROR) << "CreateOffer failed to UpdateTransportInfoForBundle.";
        return NULL;
      }
      if (!UpdateCryptoParamsForBundle(offer_bundle, offer.get())) {
        LOG(LS_ERROR) << "CreateOffer failed to UpdateCryptoParamsForBundle.";
        return NULL;
      }
    }
  
    return offer.release();
  }
  
  SessionDescription* MediaSessionDescriptionFactory::CreateAnswer(
      const SessionDescription* offer, const MediaSessionOptions& options,
      const SessionDescription* current_description) const {
    // The answer contains the intersection of the codecs in the offer with the
    // codecs we support. As indicated by XEP-0167, we retain the same payload ids
    // from the offer in the answer.
    std::unique_ptr<SessionDescription> answer(new SessionDescription());
  
    StreamParamsVec current_streams;
    GetCurrentStreamParams(current_description, &current_streams);
  
    if (offer) {
      ContentInfos::const_iterator it = offer->contents().begin();
      for (; it != offer->contents().end(); ++it) {
        if (IsMediaContentOfType(&*it, MEDIA_TYPE_AUDIO)) {
          if (!AddAudioContentForAnswer(offer, options, current_description,
                                    &current_streams, answer.get())) {
            return NULL;
          }
        } else if (IsMediaContentOfType(&*it, MEDIA_TYPE_VIDEO)) {
          if (!AddVideoContentForAnswer(offer, options, current_description,
                                        &current_streams, answer.get())) {
            return NULL;
          }
        } else {
          ASSERT(IsMediaContentOfType(&*it, MEDIA_TYPE_DATA));
          if (!AddDataContentForAnswer(offer, options, current_description,
                                       &current_streams, answer.get())) {
            return NULL;
          }
        }
      }
    }
  
    // If the offer supports BUNDLE, and we want to use it too, create a BUNDLE
    // group in the answer with the appropriate content names.
    if (offer->HasGroup(GROUP_TYPE_BUNDLE) && options.bundle_enabled) {
      const ContentGroup* offer_bundle = offer->GetGroupByName(GROUP_TYPE_BUNDLE);
      ContentGroup answer_bundle(GROUP_TYPE_BUNDLE);
      for (ContentInfos::const_iterator content = answer->contents().begin();
         content != answer->contents().end(); ++content) {
        if (!content->rejected && offer_bundle->HasContentName(content->name)) {
          answer_bundle.AddContentName(content->name);
        }
      }
      if (answer_bundle.FirstContentName()) {
        answer->AddGroup(answer_bundle);
  
        // Share the same ICE credentials and crypto params across all contents,
        // as BUNDLE requires.
        if (!UpdateTransportInfoForBundle(answer_bundle, answer.get())) {
          LOG(LS_ERROR) << "CreateAnswer failed to UpdateTransportInfoForBundle.";
          return NULL;
        }
  
        if (!UpdateCryptoParamsForBundle(answer_bundle, answer.get())) {
          LOG(LS_ERROR) << "CreateAnswer failed to UpdateCryptoParamsForBundle.";
          return NULL;
        }
      }
    }
  
    return answer.release();
  }
  
  const AudioCodecs& MediaSessionDescriptionFactory::GetAudioCodecsForOffer(
      const RtpTransceiverDirection& direction) const {
    // If stream is inactive - generate list as if sendrecv.
    if (direction.send == direction.recv) {
      return audio_sendrecv_codecs_;
    } else if (direction.send) {
      return audio_send_codecs_;
    } else {
      return audio_recv_codecs_;
    }
  }
  
  const AudioCodecs& MediaSessionDescriptionFactory::GetAudioCodecsForAnswer(
      const RtpTransceiverDirection& offer,
      const RtpTransceiverDirection& answer) const {
    // For inactive and sendrecv answers, generate lists as if we were to accept
    // the offer's direction. See RFC 3264 Section 6.1.
    if (answer.send == answer.recv) {
      if (offer.send == offer.recv) {
        return audio_sendrecv_codecs_;
      } else if (offer.send) {
        return audio_recv_codecs_;
      } else {
        return audio_send_codecs_;
      }
    } else if (answer.send) {
      return audio_send_codecs_;
    } else {
      return audio_recv_codecs_;
    }
  }
  
  void MediaSessionDescriptionFactory::GetCodecsToOffer(
      const SessionDescription* current_description,
      const AudioCodecs& supported_audio_codecs,
      const VideoCodecs& supported_video_codecs,
      const DataCodecs& supported_data_codecs,
      AudioCodecs* audio_codecs,
      VideoCodecs* video_codecs,
      DataCodecs* data_codecs) const {
    UsedPayloadTypes used_pltypes;
    audio_codecs->clear();
    video_codecs->clear();
    data_codecs->clear();
  
  
    // First - get all codecs from the current description if the media type
    // is used.
    // Add them to |used_pltypes| so the payloadtype is not reused if a new media
    // type is added.
    if (current_description) {
      const AudioContentDescription* audio =
          GetFirstAudioContentDescription(current_description);
      if (audio) {
        *audio_codecs = audio->codecs();
        used_pltypes.FindAndSetIdUsed<AudioCodec>(audio_codecs);
      }
      const VideoContentDescription* video =
          GetFirstVideoContentDescription(current_description);
      if (video) {
        *video_codecs = video->codecs();
        used_pltypes.FindAndSetIdUsed<VideoCodec>(video_codecs);
      }
      const DataContentDescription* data =
          GetFirstDataContentDescription(current_description);
      if (data) {
        *data_codecs = data->codecs();
        used_pltypes.FindAndSetIdUsed<DataCodec>(data_codecs);
      }
    }
  
    // Add our codecs that are not in |current_description|.
    FindCodecsToOffer<AudioCodec>(supported_audio_codecs, audio_codecs,
                                  &used_pltypes);
    FindCodecsToOffer<VideoCodec>(supported_video_codecs, video_codecs,
                                  &used_pltypes);
    FindCodecsToOffer<DataCodec>(supported_data_codecs, data_codecs,
                                 &used_pltypes);
  }
  
  void MediaSessionDescriptionFactory::GetRtpHdrExtsToOffer(
      const SessionDescription* current_description,
      RtpHeaderExtensions* audio_extensions,
      RtpHeaderExtensions* video_extensions) const {
    // All header extensions allocated from the same range to avoid potential
    // issues when using BUNDLE.
    UsedRtpHeaderExtensionIds used_ids;
    RtpHeaderExtensions all_extensions;
    audio_extensions->clear();
    video_extensions->clear();
  
    // First - get all extensions from the current description if the media type
    // is used.
    // Add them to |used_ids| so the local ids are not reused if a new media
    // type is added.
    if (current_description) {
      const AudioContentDescription* audio =
          GetFirstAudioContentDescription(current_description);
      if (audio) {
        *audio_extensions = audio->rtp_header_extensions();
        FindAndSetRtpHdrExtUsed(audio_extensions, &all_extensions, &used_ids);
      }
      const VideoContentDescription* video =
          GetFirstVideoContentDescription(current_description);
      if (video) {
        *video_extensions = video->rtp_header_extensions();
        FindAndSetRtpHdrExtUsed(video_extensions, &all_extensions, &used_ids);
      }
    }
  
    // Add our default RTP header extensions that are not in
    // |current_description|.
    FindRtpHdrExtsToOffer(audio_rtp_header_extensions(), audio_extensions,
                          &all_extensions, &used_ids);
    FindRtpHdrExtsToOffer(video_rtp_header_extensions(), video_extensions,
                          &all_extensions, &used_ids);
  }
  
  bool MediaSessionDescriptionFactory::AddTransportOffer(
    const std::string& content_name,
    const TransportOptions& transport_options,
    const SessionDescription* current_desc,
    SessionDescription* offer_desc) const {
    if (!transport_desc_factory_)
       return false;
    const TransportDescription* current_tdesc =
        GetTransportDescription(content_name, current_desc);
    std::unique_ptr<TransportDescription> new_tdesc(
        transport_desc_factory_->CreateOffer(transport_options, current_tdesc));
    bool ret = (new_tdesc.get() != NULL &&
        offer_desc->AddTransportInfo(TransportInfo(content_name, *new_tdesc)));
    if (!ret) {
      LOG(LS_ERROR)
          << "Failed to AddTransportOffer, content name=" << content_name;
    }
    return ret;
  }
  
  TransportDescription* MediaSessionDescriptionFactory::CreateTransportAnswer(
      const std::string& content_name,
      const SessionDescription* offer_desc,
      const TransportOptions& transport_options,
      const SessionDescription* current_desc) const {
    if (!transport_desc_factory_)
      return NULL;
    const TransportDescription* offer_tdesc =
        GetTransportDescription(content_name, offer_desc);
    const TransportDescription* current_tdesc =
        GetTransportDescription(content_name, current_desc);
    return
        transport_desc_factory_->CreateAnswer(offer_tdesc, transport_options,
                                              current_tdesc);
  }
  
  bool MediaSessionDescriptionFactory::AddTransportAnswer(
      const std::string& content_name,
      const TransportDescription& transport_desc,
      SessionDescription* answer_desc) const {
    if (!answer_desc->AddTransportInfo(TransportInfo(content_name,
                                                     transport_desc))) {
      LOG(LS_ERROR)
          << "Failed to AddTransportAnswer, content name=" << content_name;
      return false;
    }
    return true;
  }
  
  bool MediaSessionDescriptionFactory::AddAudioContentForOffer(
      const MediaSessionOptions& options,
      const SessionDescription* current_description,
      const RtpHeaderExtensions& audio_rtp_extensions,
      const AudioCodecs& audio_codecs,
      StreamParamsVec* current_streams,
      SessionDescription* desc) const {
    const ContentInfo* current_audio_content =
        GetFirstAudioContent(current_description);
    std::string content_name =
        current_audio_content ? current_audio_content->name : CN_AUDIO;
  
    cricket::SecurePolicy sdes_policy =
        IsDtlsActive(content_name, current_description) ? cricket::SEC_DISABLED
                                                        : secure();
  
    std::unique_ptr<AudioContentDescription> audio(new AudioContentDescription());
    std::vector<std::string> 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())) {
      return false;
    }
    audio->set_lang(lang_);
  
    bool secure_transport = (transport_desc_factory_->secure() != SEC_DISABLED);
    SetMediaProtocol(secure_transport, audio.get());
  
    auto offer_rtd =
        RtpTransceiverDirection(!audio->streams().empty(), options.recv_audio);
    audio->set_direction(offer_rtd.ToMediaContentDirection());
  
    desc->AddContent(content_name, NS_JINGLE_RTP, audio.release());
    if (!AddTransportOffer(content_name,
                           GetTransportOptions(options, content_name),
                           current_description, desc)) {
      return false;
    }
  
    return true;
  }
  
  bool MediaSessionDescriptionFactory::AddVideoContentForOffer(
      const MediaSessionOptions& options,
      const SessionDescription* current_description,
      const RtpHeaderExtensions& video_rtp_extensions,
      const VideoCodecs& video_codecs,
      StreamParamsVec* current_streams,
      SessionDescription* desc) const {
    const ContentInfo* current_video_content =
        GetFirstVideoContent(current_description);
    std::string content_name =
        current_video_content ? current_video_content->name : CN_VIDEO;
  
    cricket::SecurePolicy sdes_policy =
        IsDtlsActive(content_name, current_description) ? cricket::SEC_DISABLED
                                                        : secure();
  
    std::unique_ptr<VideoContentDescription> video(new VideoContentDescription());
    std::vector<std::string> 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())) {
      return false;
    }
  
    video->set_bandwidth(options.video_bandwidth);
  
    bool secure_transport = (transport_desc_factory_->secure() != SEC_DISABLED);
    SetMediaProtocol(secure_transport, video.get());
  
    if (!video->streams().empty()) {
      if (options.recv_video) {
        video->set_direction(MD_SENDRECV);
      } else {
        video->set_direction(MD_SENDONLY);
      }
    } else {
      if (options.recv_video) {
        video->set_direction(MD_RECVONLY);
      } else {
        video->set_direction(MD_INACTIVE);
      }
    }
  
    desc->AddContent(content_name, NS_JINGLE_RTP, video.release());
    if (!AddTransportOffer(content_name,
                           GetTransportOptions(options, content_name),
                           current_description, desc)) {
      return false;
    }
  
    return true;
  }
  
  bool MediaSessionDescriptionFactory::AddDataContentForOffer(
      const MediaSessionOptions& options,
      const SessionDescription* current_description,
      DataCodecs* data_codecs,
      StreamParamsVec* current_streams,
      SessionDescription* desc) const {
    bool secure_transport = (transport_desc_factory_->secure() != SEC_DISABLED);
  
    std::unique_ptr<DataContentDescription> data(new DataContentDescription());
    bool is_sctp = (options.data_channel_type == DCT_SCTP);
  
    FilterDataCodecs(data_codecs, is_sctp);
  
    const ContentInfo* current_data_content =
        GetFirstDataContent(current_description);
    std::string content_name =
        current_data_content ? current_data_content->name : CN_DATA;
  
    cricket::SecurePolicy sdes_policy =
        IsDtlsActive(content_name, current_description) ? cricket::SEC_DISABLED
                                                        : secure();
    std::vector<std::string> crypto_suites;
    if (is_sctp) {
      // 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 {
      GetSupportedDataCryptoSuiteNames(&crypto_suites);
    }
  
    if (!CreateMediaContentOffer(
            options,
            *data_codecs,
            sdes_policy,
            GetCryptos(GetFirstDataContentDescription(current_description)),
            crypto_suites,
            RtpHeaderExtensions(),
            add_legacy_,
            current_streams,
            data.get())) {
      return false;
    }
  
    if (is_sctp) {
      desc->AddContent(content_name, NS_JINGLE_DRAFT_SCTP, data.release());
    } else {
      data->set_bandwidth(options.data_bandwidth);
      SetMediaProtocol(secure_transport, data.get());
      desc->AddContent(content_name, NS_JINGLE_RTP, data.release());
    }
    if (!AddTransportOffer(content_name,
                           GetTransportOptions(options, content_name),
                           current_description, desc)) {
      return false;
    }
    return true;
  }
  
  bool MediaSessionDescriptionFactory::AddAudioContentForAnswer(
      const SessionDescription* offer,
      const MediaSessionOptions& options,
      const SessionDescription* current_description,
      StreamParamsVec* current_streams,
      SessionDescription* answer) const {
    const ContentInfo* audio_content = GetFirstAudioContent(offer);
    const AudioContentDescription* offer_audio =
        static_cast<const AudioContentDescription*>(audio_content->description);
  
    std::unique_ptr<TransportDescription> audio_transport(CreateTransportAnswer(
        audio_content->name, offer,
        GetTransportOptions(options, audio_content->name), current_description));
    if (!audio_transport) {
      return false;
    }
  
    // Pick codecs based on the requested communications direction in the offer.
    const bool wants_send =
        options.HasSendMediaStream(MEDIA_TYPE_AUDIO) || add_legacy_;
    auto wants_rtd = RtpTransceiverDirection(wants_send, options.recv_audio);
    auto offer_rtd =
        RtpTransceiverDirection::FromMediaContentDirection(
            offer_audio->direction());
    auto answer_rtd = NegotiateRtpTransceiverDirection(offer_rtd, wants_rtd);
    AudioCodecs audio_codecs = GetAudioCodecsForAnswer(offer_rtd, answer_rtd);
    if (!options.vad_enabled) {
      StripCNCodecs(&audio_codecs);
    }
  
    bool bundle_enabled =
        offer->HasGroup(GROUP_TYPE_BUNDLE) && options.bundle_enabled;
    std::unique_ptr<AudioContentDescription> audio_answer(
        new AudioContentDescription());
    // Do not require or create SDES cryptos if DTLS is used.
    cricket::SecurePolicy sdes_policy =
        audio_transport->secure() ? cricket::SEC_DISABLED : secure();
    if (!CreateMediaContentAnswer(
            offer_audio,
            options,
            audio_codecs,
            sdes_policy,
            GetCryptos(GetFirstAudioContentDescription(current_description)),
            audio_rtp_extensions_,
            current_streams,
            add_legacy_,
            bundle_enabled,
            audio_answer.get())) {
      return false;  // Fails the session setup.
    }
  
    bool rejected = !options.has_audio() || audio_content->rejected ||
        !IsMediaProtocolSupported(MEDIA_TYPE_AUDIO,
                                  audio_answer->protocol(),
                                  audio_transport->secure());
    if (!rejected) {
      AddTransportAnswer(audio_content->name, *(audio_transport.get()), answer);
    } else {
      // RFC 3264
      // The answer MUST contain the same number of m-lines as the offer.
      LOG(LS_INFO) << "Audio is not supported in the answer.";
    }
  
    answer->AddContent(audio_content->name, audio_content->type, rejected,
                       audio_answer.release());
    return true;
  }
  
  bool MediaSessionDescriptionFactory::AddVideoContentForAnswer(
      const SessionDescription* offer,
      const MediaSessionOptions& options,
      const SessionDescription* current_description,
      StreamParamsVec* current_streams,
      SessionDescription* answer) const {
    const ContentInfo* video_content = GetFirstVideoContent(offer);
    std::unique_ptr<TransportDescription> video_transport(CreateTransportAnswer(
        video_content->name, offer,
        GetTransportOptions(options, video_content->name), current_description));
    if (!video_transport) {
      return false;
    }
  
    std::unique_ptr<VideoContentDescription> video_answer(
        new VideoContentDescription());
    // Do not require or create SDES cryptos if DTLS is used.
    cricket::SecurePolicy sdes_policy =
        video_transport->secure() ? cricket::SEC_DISABLED : secure();
    bool bundle_enabled =
        offer->HasGroup(GROUP_TYPE_BUNDLE) && options.bundle_enabled;
    if (!CreateMediaContentAnswer(
            static_cast<const VideoContentDescription*>(
                video_content->description),
            options,
            video_codecs_,
            sdes_policy,
            GetCryptos(GetFirstVideoContentDescription(current_description)),
            video_rtp_extensions_,
            current_streams,
            add_legacy_,
            bundle_enabled,
            video_answer.get())) {
      return false;
    }
    bool rejected = !options.has_video() || video_content->rejected ||
        !IsMediaProtocolSupported(MEDIA_TYPE_VIDEO,
                                  video_answer->protocol(),
                                  video_transport->secure());
    if (!rejected) {
      if (!AddTransportAnswer(video_content->name, *(video_transport.get()),
                              answer)) {
        return false;
      }
      video_answer->set_bandwidth(options.video_bandwidth);
    } else {
      // RFC 3264
      // The answer MUST contain the same number of m-lines as the offer.
      LOG(LS_INFO) << "Video is not supported in the answer.";
    }
    answer->AddContent(video_content->name, video_content->type, rejected,
                       video_answer.release());
    return true;
  }
  
  bool MediaSessionDescriptionFactory::AddDataContentForAnswer(
      const SessionDescription* offer,
      const MediaSessionOptions& options,
      const SessionDescription* current_description,
      StreamParamsVec* current_streams,
      SessionDescription* answer) const {
    const ContentInfo* data_content = GetFirstDataContent(offer);
    std::unique_ptr<TransportDescription> data_transport(CreateTransportAnswer(
        data_content->name, offer,
        GetTransportOptions(options, data_content->name), current_description));
    if (!data_transport) {
      return false;
    }
    bool is_sctp = (options.data_channel_type == DCT_SCTP);
    std::vector<DataCodec> data_codecs(data_codecs_);
    FilterDataCodecs(&data_codecs, is_sctp);
  
    std::unique_ptr<DataContentDescription> data_answer(
        new DataContentDescription());
    // Do not require or create SDES cryptos if DTLS is used.
    cricket::SecurePolicy sdes_policy =
        data_transport->secure() ? cricket::SEC_DISABLED : secure();
    bool bundle_enabled =
        offer->HasGroup(GROUP_TYPE_BUNDLE) && options.bundle_enabled;
    if (!CreateMediaContentAnswer(
            static_cast<const DataContentDescription*>(
                data_content->description),
            options,
            data_codecs_,
            sdes_policy,
            GetCryptos(GetFirstDataContentDescription(current_description)),
            RtpHeaderExtensions(),
            current_streams,
            add_legacy_,
            bundle_enabled,
            data_answer.get())) {
      return false;  // Fails the session setup.
    }
  
    bool rejected = !options.has_data() || data_content->rejected ||
        !IsMediaProtocolSupported(MEDIA_TYPE_DATA,
                                  data_answer->protocol(),
                                  data_transport->secure());
    if (!rejected) {
      data_answer->set_bandwidth(options.data_bandwidth);
      if (!AddTransportAnswer(data_content->name, *(data_transport.get()),
                              answer)) {
        return false;
      }
    } else {
      // RFC 3264
      // The answer MUST contain the same number of m-lines as the offer.
      LOG(LS_INFO) << "Data is not supported in the answer.";
    }
    answer->AddContent(data_content->name, data_content->type, rejected,
                       data_answer.release());
    return true;
  }
  
  bool IsMediaContent(const ContentInfo* content) {
    return (content &&
            (content->type == NS_JINGLE_RTP ||
             content->type == NS_JINGLE_DRAFT_SCTP));
  }
  
  bool IsAudioContent(const ContentInfo* content) {
    return IsMediaContentOfType(content, MEDIA_TYPE_AUDIO);
  }
  
  bool IsVideoContent(const ContentInfo* content) {
    return IsMediaContentOfType(content, MEDIA_TYPE_VIDEO);
  }
  
  bool IsDataContent(const ContentInfo* content) {
    return IsMediaContentOfType(content, MEDIA_TYPE_DATA);
  }
  
  const ContentInfo* GetFirstMediaContent(const ContentInfos& contents,
                                          MediaType media_type) {
    for (const ContentInfo& content : contents) {
      if (IsMediaContentOfType(&content, media_type)) {
        return &content;
      }
    }
    return nullptr;
  }
  
  const ContentInfo* GetFirstAudioContent(const ContentInfos& contents) {
    return GetFirstMediaContent(contents, MEDIA_TYPE_AUDIO);
  }
  
  const ContentInfo* GetFirstVideoContent(const ContentInfos& contents) {
    return GetFirstMediaContent(contents, MEDIA_TYPE_VIDEO);
  }
  
  const ContentInfo* GetFirstDataContent(const ContentInfos& contents) {
    return GetFirstMediaContent(contents, MEDIA_TYPE_DATA);
  }
  
  static const ContentInfo* GetFirstMediaContent(const SessionDescription* sdesc,
                                                 MediaType media_type) {
    if (sdesc == nullptr) {
      return nullptr;
    }
  
    return GetFirstMediaContent(sdesc->contents(), media_type);
  }
  
  const ContentInfo* GetFirstAudioContent(const SessionDescription* sdesc) {
    return GetFirstMediaContent(sdesc, MEDIA_TYPE_AUDIO);
  }
  
  const ContentInfo* GetFirstVideoContent(const SessionDescription* sdesc) {
    return GetFirstMediaContent(sdesc, MEDIA_TYPE_VIDEO);
  }
  
  const ContentInfo* GetFirstDataContent(const SessionDescription* sdesc) {
    return GetFirstMediaContent(sdesc, MEDIA_TYPE_DATA);
  }
  
  const MediaContentDescription* GetFirstMediaContentDescription(
      const SessionDescription* sdesc, MediaType media_type) {
    const ContentInfo* content = GetFirstMediaContent(sdesc, media_type);
    const ContentDescription* description = content ? content->description : NULL;
    return static_cast<const MediaContentDescription*>(description);
  }
  
  const AudioContentDescription* GetFirstAudioContentDescription(
      const SessionDescription* sdesc) {
    return static_cast<const AudioContentDescription*>(
        GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_AUDIO));
  }
  
  const VideoContentDescription* GetFirstVideoContentDescription(
      const SessionDescription* sdesc) {
    return static_cast<const VideoContentDescription*>(
        GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_VIDEO));
  }
  
  const DataContentDescription* GetFirstDataContentDescription(
      const SessionDescription* sdesc) {
    return static_cast<const DataContentDescription*>(
        GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_DATA));
  }
  
  //
  // Non-const versions of the above functions.
  //
  
  ContentInfo* GetFirstMediaContent(ContentInfos& contents,
                                    MediaType media_type) {
    for (ContentInfo& content : contents) {
      if (IsMediaContentOfType(&content, media_type)) {
        return &content;
      }
    }
    return nullptr;
  }
  
  ContentInfo* GetFirstAudioContent(ContentInfos& contents) {
    return GetFirstMediaContent(contents, MEDIA_TYPE_AUDIO);
  }
  
  ContentInfo* GetFirstVideoContent(ContentInfos& contents) {
    return GetFirstMediaContent(contents, MEDIA_TYPE_VIDEO);
  }
  
  ContentInfo* GetFirstDataContent(ContentInfos& contents) {
    return GetFirstMediaContent(contents, MEDIA_TYPE_DATA);
  }
  
  static ContentInfo* GetFirstMediaContent(SessionDescription* sdesc,
                                           MediaType media_type) {
    if (sdesc == nullptr) {
      return nullptr;
    }
  
    return GetFirstMediaContent(sdesc->contents(), media_type);
  }
  
  ContentInfo* GetFirstAudioContent(SessionDescription* sdesc) {
    return GetFirstMediaContent(sdesc, MEDIA_TYPE_AUDIO);
  }
  
  ContentInfo* GetFirstVideoContent(SessionDescription* sdesc) {
    return GetFirstMediaContent(sdesc, MEDIA_TYPE_VIDEO);
  }
  
  ContentInfo* GetFirstDataContent(SessionDescription* sdesc) {
    return GetFirstMediaContent(sdesc, MEDIA_TYPE_DATA);
  }
  
  MediaContentDescription* GetFirstMediaContentDescription(
      SessionDescription* sdesc,
      MediaType media_type) {
    ContentInfo* content = GetFirstMediaContent(sdesc, media_type);
    ContentDescription* description = content ? content->description : NULL;
    return static_cast<MediaContentDescription*>(description);
  }
  
  AudioContentDescription* GetFirstAudioContentDescription(
      SessionDescription* sdesc) {
    return static_cast<AudioContentDescription*>(
        GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_AUDIO));
  }
  
  VideoContentDescription* GetFirstVideoContentDescription(
      SessionDescription* sdesc) {
    return static_cast<VideoContentDescription*>(
        GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_VIDEO));
  }
  
  DataContentDescription* GetFirstDataContentDescription(
      SessionDescription* sdesc) {
    return static_cast<DataContentDescription*>(
        GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_DATA));
  }
  
  }  // namespace cricket
  