Support "UDP/DTLS/SCTP" and "TCP/DTLS/SCTP" profile strings.

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 49 matching lines @@
 // 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";
 
+// Note that the below functions support some protocol strings purely for
+// legacy compatibility, as required by JSEP in Section 5.1.2, Profile Names
+// and Interoperability.
+
+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 == kMediaProtocolDtlsSctp ||
+         protocol == kMediaProtocolUdpDtlsSctp ||
+         protocol == kMediaProtocolTcpDtlsSctp;

[Taylor Brandstetter, 2017/05/24 17:43:21]

This is the only method that was changed and not just moved (well, this and
IsSctp).

+}
+
+static bool IsPlainSctp(const std::string& protocol) {
+  return protocol == kMediaProtocolSctp;
+}
+
+static bool IsSctp(const std::string& protocol) {
+  return IsPlainSctp(protocol) || IsDtlsSctp(protocol);
+}
+
 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;
@@ skipping 311 matching lines @@
 // audio and video extensions.
 class UsedRtpHeaderExtensionIds : public UsedIds<webrtc::RtpExtension> {
  public:
   UsedRtpHeaderExtensionIds()
       : UsedIds<webrtc::RtpExtension>(webrtc::RtpExtension::kMinId,
                                       webrtc::RtpExtension::kMaxId) {}
 
  private:
 };
 
-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) {
   // SCTP streams are not negotiated using SDP/ContentDescriptions.
-  if (IsSctp(content_description)) {
+  if (IsSctp(content_description->protocol())) {
     return true;
   }
 
   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;
@@ skipping 651 matching lines @@
   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) {
@@ skipping 232 matching lines @@
         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))) {
+        if (IsSctp(static_cast<const MediaContentDescription*>(it->description)
+                       ->protocol())) {
           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 {
         RTC_NOTREACHED();
@@ skipping 418 matching lines @@
                                                       : 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.
+    // TODO(deadbeef): Use kMediaProtocolDtls
     data->set_protocol(
         secure_transport ? kMediaProtocolDtlsSctp : kMediaProtocolSctp);
   } else {
     GetSupportedDataSdesCryptoSuiteNames(options.crypto_options,
                                          &crypto_suites);
   }
 
   if (!CreateMediaContentOffer(
           options,
           *data_codecs,
@@ skipping 373 matching lines @@
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_VIDEO));
 }
 
 DataContentDescription* GetFirstDataContentDescription(
     SessionDescription* sdesc) {
   return static_cast<DataContentDescription*>(
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_DATA));
 }
 
 }  // namespace cricket