Use the same draft version in SDP data channel answers as used in the offer.

webrtc/pc/webrtcsdp_unittest.cc

 /*
  *  Copyright 2011 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 47 matching lines @@
 using webrtc::JsepIceCandidate;
 using webrtc::JsepSessionDescription;
 using webrtc::RtpExtension;
 using webrtc::SdpParseError;
 using webrtc::SessionDescriptionInterface;
 
 typedef std::vector<AudioCodec> AudioCodecs;
 typedef std::vector<Candidate> Candidates;
 
 static const uint32_t kDefaultSctpPort = 5000;
+static const char kDefaultSctpPortStr[] = "5000";
+static const uint16_t kUnusualSctpPort = 9556;
+static const char kUnusualSctpPortStr[] = "9556";
 static const char kSessionTime[] = "t=0 0\r\n";
 static const uint32_t kCandidatePriority = 2130706432U;  // pref = 1.0
 static const char kAttributeIceUfragVoice[] = "a=ice-ufrag:ufrag_voice\r\n";
 static const char kAttributeIcePwdVoice[] = "a=ice-pwd:pwd_voice\r\n";
 static const char kAttributeIceUfragVideo[] = "a=ice-ufrag:ufrag_video\r\n";
 static const char kAttributeIcePwdVideo[] = "a=ice-pwd:pwd_video\r\n";
 static const uint32_t kCandidateGeneration = 2;
 static const char kCandidateFoundation1[] = "a0+B/1";
 static const char kCandidateFoundation2[] = "a0+B/2";
 static const char kCandidateFoundation3[] = "a0+B/3";
@@ skipping 1125 matching lines @@
     ASSERT_EQ(cd1->rtp_header_extensions().size(),
               cd2->rtp_header_extensions().size());
     for (size_t i = 0; i< cd1->rtp_header_extensions().size(); ++i) {
       const RtpExtension ext1 = cd1->rtp_header_extensions().at(i);
       const RtpExtension ext2 = cd2->rtp_header_extensions().at(i);
       EXPECT_EQ(ext1.uri, ext2.uri);
       EXPECT_EQ(ext1.id, ext2.id);
     }
   }
 
+  void CompareDataContentDescription(const DataContentDescription* dcd1,
+                                     const DataContentDescription* dcd2) {
+    EXPECT_EQ(dcd1->use_sctpmap(), dcd2->use_sctpmap());
+    CompareMediaContentDescription<DataContentDescription>(dcd1, dcd2);
+  }
 
   void CompareSessionDescription(const SessionDescription& desc1,
                                  const SessionDescription& desc2) {
     // Compare content descriptions.
     if (desc1.contents().size() != desc2.contents().size()) {
       ADD_FAILURE();
       return;
     }
     for (size_t i = 0 ; i < desc1.contents().size(); ++i) {
       const cricket::ContentInfo& c1 = desc1.contents().at(i);
@@ skipping 21 matching lines @@
             static_cast<const VideoContentDescription*>(c2.description);
         CompareMediaContentDescription<VideoContentDescription>(vcd1, vcd2);
       }
 
       ASSERT_EQ(IsDataContent(&c1), IsDataContent(&c2));
       if (IsDataContent(&c1)) {
         const DataContentDescription* dcd1 =
             static_cast<const DataContentDescription*>(c1.description);
         const DataContentDescription* dcd2 =
             static_cast<const DataContentDescription*>(c2.description);
-        CompareMediaContentDescription<DataContentDescription>(dcd1, dcd2);
+        CompareDataContentDescription(dcd1, dcd2);
       }
     }
 
     // group
     const cricket::ContentGroups groups1 = desc1.groups();
     const cricket::ContentGroups groups2 = desc2.groups();
     EXPECT_EQ(groups1.size(), groups1.size());
     if (groups1.size() != groups2.size()) {
       ADD_FAILURE();
       return;
@@ skipping 214 matching lines @@
     JsepSessionDescription jdesc_no_candidates(kDummyString);
     if (!jdesc_no_candidates.Initialize(desc_.Copy(), kSessionId,
                                         kSessionVersion)) {
       return false;
     }
     std::string message = webrtc::SdpSerialize(jdesc_no_candidates, false);
     EXPECT_EQ(new_sdp, message);
     return true;
   }
 
-  void AddSctpDataChannel() {
+  void AddSctpDataChannel(bool use_sctpmap) {
     std::unique_ptr<DataContentDescription> data(new DataContentDescription());
     data_desc_ = data.get();
+    data_desc_->set_use_sctpmap(use_sctpmap);
     data_desc_->set_protocol(cricket::kMediaProtocolDtlsSctp);
     DataCodec codec(cricket::kGoogleSctpDataCodecPlType,
                     cricket::kGoogleSctpDataCodecName);
     codec.SetParam(cricket::kCodecParamPort, kDefaultSctpPort);
     data_desc_->AddCodec(codec);
     desc_.AddContent(kDataContentName, NS_JINGLE_DRAFT_SCTP, data.release());
     EXPECT_TRUE(desc_.AddTransportInfo(TransportInfo(
         kDataContentName, TransportDescription(kUfragData, kPwdData))));
   }
 
@@ skipping 549 matching lines @@
 
   ASSERT_TRUE(jsep_desc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
   std::string message = webrtc::SdpSerialize(jsep_desc, false);
 
   std::string expected_sdp = kSdpString;
   expected_sdp.append(kSdpRtpDataChannelString);
   EXPECT_EQ(expected_sdp, message);
 }
 
 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithSctpDataChannel) {
-  AddSctpDataChannel();
+  bool use_sctpmap = true;
+  AddSctpDataChannel(use_sctpmap);
   JsepSessionDescription jsep_desc(kDummyString);
 
   ASSERT_TRUE(jsep_desc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
   std::string message = webrtc::SdpSerialize(jsep_desc, false);
 
   std::string expected_sdp = kSdpString;
   expected_sdp.append(kSdpSctpDataChannelString);
   EXPECT_EQ(message, expected_sdp);
 }
 
 TEST_F(WebRtcSdpTest, SerializeWithSctpDataChannelAndNewPort) {
-  AddSctpDataChannel();
+  bool use_sctpmap = true;
+  AddSctpDataChannel(use_sctpmap);
   JsepSessionDescription jsep_desc(kDummyString);
 
   ASSERT_TRUE(jsep_desc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
   DataContentDescription* dcdesc = static_cast<DataContentDescription*>(
       jsep_desc.description()->GetContentDescriptionByName(kDataContentName));
 
   const int kNewPort = 1234;
   cricket::DataCodec codec(cricket::kGoogleSctpDataCodecPlType,
                            cricket::kGoogleSctpDataCodecName);
   codec.SetParam(cricket::kCodecParamPort, kNewPort);
@@ skipping 479 matching lines @@
   sdp_with_data.append(kSdpRtpDataChannelString);
   JsepSessionDescription jdesc_output(kDummyString);
 
   // Deserialize
   EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
   // Verify
   EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
 }
 
 TEST_F(WebRtcSdpTest, DeserializeSdpWithSctpDataChannels) {
-  AddSctpDataChannel();
+  bool use_sctpmap = true;
+  AddSctpDataChannel(use_sctpmap);
   JsepSessionDescription jdesc(kDummyString);
   ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
 
   std::string sdp_with_data = kSdpString;
   sdp_with_data.append(kSdpSctpDataChannelString);
   JsepSessionDescription jdesc_output(kDummyString);
 
   // Verify with DTLS/SCTP (already in kSdpSctpDataChannelString).
   EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
   EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
 
   // Verify with UDP/DTLS/SCTP.
   sdp_with_data.replace(sdp_with_data.find(kDtlsSctp),
                         strlen(kDtlsSctp), kUdpDtlsSctp);
   EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
   EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
 
   // Verify with TCP/DTLS/SCTP.
   sdp_with_data.replace(sdp_with_data.find(kUdpDtlsSctp),
                         strlen(kUdpDtlsSctp), kTcpDtlsSctp);
   EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
   EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
 }
 
 TEST_F(WebRtcSdpTest, DeserializeSdpWithSctpDataChannelsWithSctpPort) {
-  AddSctpDataChannel();
+  bool use_sctpmap = false;
+  AddSctpDataChannel(use_sctpmap);
   JsepSessionDescription jdesc(kDummyString);
   ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
 
   std::string sdp_with_data = kSdpString;
   sdp_with_data.append(kSdpSctpDataChannelStringWithSctpPort);
   JsepSessionDescription jdesc_output(kDummyString);
 
   // Verify with DTLS/SCTP (already in kSdpSctpDataChannelStringWithSctpPort).
   EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
   EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
 
   // Verify with UDP/DTLS/SCTP.
   sdp_with_data.replace(sdp_with_data.find(kDtlsSctp),
                         strlen(kDtlsSctp), kUdpDtlsSctp);
   EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
   EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
 
   // Verify with TCP/DTLS/SCTP.
   sdp_with_data.replace(sdp_with_data.find(kUdpDtlsSctp),
                         strlen(kUdpDtlsSctp), kTcpDtlsSctp);
   EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
   EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
 }
 
 TEST_F(WebRtcSdpTest, DeserializeSdpWithSctpDataChannelsWithSctpColonPort) {
-  AddSctpDataChannel();
+  bool use_sctpmap = false;
+  AddSctpDataChannel(use_sctpmap);
   JsepSessionDescription jdesc(kDummyString);
   ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
 
   std::string sdp_with_data = kSdpString;
   sdp_with_data.append(kSdpSctpDataChannelStringWithSctpColonPort);
   JsepSessionDescription jdesc_output(kDummyString);
 
   // Verify with DTLS/SCTP.
   EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
   EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
 
   // Verify with UDP/DTLS/SCTP.
   sdp_with_data.replace(sdp_with_data.find(kDtlsSctp),
                         strlen(kDtlsSctp), kUdpDtlsSctp);
   EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
   EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
 
   // Verify with TCP/DTLS/SCTP.
   sdp_with_data.replace(sdp_with_data.find(kUdpDtlsSctp),
                         strlen(kUdpDtlsSctp), kTcpDtlsSctp);
   EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
   EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
 }
 
 // Test to check the behaviour if sctp-port is specified
 // on the m= line and in a=sctp-port.
 TEST_F(WebRtcSdpTest, DeserializeSdpWithMultiSctpPort) {
-  AddSctpDataChannel();
+  bool use_sctpmap = true;
+  AddSctpDataChannel(use_sctpmap);
   JsepSessionDescription jdesc(kDummyString);
   ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
 
   std::string sdp_with_data = kSdpString;
   // Append m= attributes
   sdp_with_data.append(kSdpSctpDataChannelString);
   // Append a=sctp-port attribute
   sdp_with_data.append("a=sctp-port 5000\r\n");
   JsepSessionDescription jdesc_output(kDummyString);
 
   EXPECT_FALSE(SdpDeserialize(sdp_with_data, &jdesc_output));
 }
 
 // For crbug/344475.
 TEST_F(WebRtcSdpTest, DeserializeSdpWithCorruptedSctpDataChannels) {
   std::string sdp_with_data = kSdpString;
   sdp_with_data.append(kSdpSctpDataChannelString);
   // Remove the "\n" at the end.
   sdp_with_data = sdp_with_data.substr(0, sdp_with_data.size() - 1);
   JsepSessionDescription jdesc_output(kDummyString);
 
   EXPECT_FALSE(SdpDeserialize(sdp_with_data, &jdesc_output));
   // No crash is a pass.
 }
 
-TEST_F(WebRtcSdpTest, DeserializeSdpWithSctpDataChannelAndNewPort) {
-  AddSctpDataChannel();
-  const uint16_t kUnusualSctpPort = 9556;
-  char default_portstr[16];
-  char unusual_portstr[16];
-  rtc::sprintfn(default_portstr, sizeof(default_portstr), "%d",
-                      kDefaultSctpPort);
-  rtc::sprintfn(unusual_portstr, sizeof(unusual_portstr), "%d",
-                      kUnusualSctpPort);
-
-  // First setup the expected JsepSessionDescription.
-  JsepSessionDescription jdesc(kDummyString);
+void MutateJsepSctpPort(JsepSessionDescription& jdesc,
+                        const SessionDescription& desc) {
   // take our pre-built session description and change the SCTP port.
-  cricket::SessionDescription* mutant = desc_.Copy();
+  cricket::SessionDescription* mutant = desc.Copy();
   DataContentDescription* dcdesc = static_cast<DataContentDescription*>(
       mutant->GetContentDescriptionByName(kDataContentName));
   std::vector<cricket::DataCodec> codecs(dcdesc->codecs());
   EXPECT_EQ(1U, codecs.size());
   EXPECT_EQ(cricket::kGoogleSctpDataCodecPlType, codecs[0].id);
   codecs[0].SetParam(cricket::kCodecParamPort, kUnusualSctpPort);
   dcdesc->set_codecs(codecs);
 
   // note: mutant's owned by jdesc now.
   ASSERT_TRUE(jdesc.Initialize(mutant, kSessionId, kSessionVersion));
   mutant = NULL;
+}
+
+TEST_F(WebRtcSdpTest, DeserializeSdpWithSctpDataChannelAndUnusualPort) {
+  bool use_sctpmap = true;
+  AddSctpDataChannel(use_sctpmap);
+
+  // First setup the expected JsepSessionDescription.
+  JsepSessionDescription jdesc(kDummyString);
+  MutateJsepSctpPort(jdesc, desc_);
 
   // Then get the deserialized JsepSessionDescription.
   std::string sdp_with_data = kSdpString;
   sdp_with_data.append(kSdpSctpDataChannelString);
-  rtc::replace_substrs(default_portstr, strlen(default_portstr),
-                             unusual_portstr, strlen(unusual_portstr),
-                             &sdp_with_data);
+  rtc::replace_substrs(kDefaultSctpPortStr, strlen(kDefaultSctpPortStr),
+                       kUnusualSctpPortStr, strlen(kUnusualSctpPortStr),
+                       &sdp_with_data);
   JsepSessionDescription jdesc_output(kDummyString);
 
   EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
   EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
+}
+
+TEST_F(WebRtcSdpTest,
+       DeserializeSdpWithSctpDataChannelAndUnusualPortInAttribute) {
+  bool use_sctpmap = false;
+  AddSctpDataChannel(use_sctpmap);
+
+  JsepSessionDescription jdesc(kDummyString);
+  MutateJsepSctpPort(jdesc, desc_);
 
   // We need to test the deserialized JsepSessionDescription from
   // kSdpSctpDataChannelStringWithSctpPort for
   // draft-ietf-mmusic-sctp-sdp-07
   // a=sctp-port
-  sdp_with_data = kSdpString;
+  std::string sdp_with_data = kSdpString;
   sdp_with_data.append(kSdpSctpDataChannelStringWithSctpPort);
-  rtc::replace_substrs(default_portstr, strlen(default_portstr),
-                             unusual_portstr, strlen(unusual_portstr),
-                             &sdp_with_data);
+  rtc::replace_substrs(kDefaultSctpPortStr, strlen(kDefaultSctpPortStr),
+                       kUnusualSctpPortStr, strlen(kUnusualSctpPortStr),
+                       &sdp_with_data);
+  JsepSessionDescription jdesc_output(kDummyString);
 
   EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
   EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
 }
 
 TEST_F(WebRtcSdpTest, DeserializeSdpWithRtpDataChannelsAndBandwidth) {
   // We want to test that deserializing data content limits bandwidth
   // settings (it should never be greater than the default).
   // This should prevent someone from using unlimited data bandwidth through
   // JS and "breaking the Internet".
   // See: https://code.google.com/p/chromium/issues/detail?id=280726
   std::string sdp_with_bandwidth = kSdpString;
   sdp_with_bandwidth.append(kSdpRtpDataChannelString);
   InjectAfter("a=mid:data_content_name\r\n",
               "b=AS:100\r\n",
               &sdp_with_bandwidth);
   JsepSessionDescription jdesc_with_bandwidth(kDummyString);
 
   EXPECT_FALSE(SdpDeserialize(sdp_with_bandwidth, &jdesc_with_bandwidth));
 }
 
 TEST_F(WebRtcSdpTest, DeserializeSdpWithSctpDataChannelsAndBandwidth) {
-  AddSctpDataChannel();
+  bool use_sctpmap = true;
+  AddSctpDataChannel(use_sctpmap);
   JsepSessionDescription jdesc(kDummyString);
   DataContentDescription* dcd = static_cast<DataContentDescription*>(
      GetFirstDataContent(&desc_)->description);
   dcd->set_bandwidth(100 * 1000);
   ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
 
   std::string sdp_with_bandwidth = kSdpString;
   sdp_with_bandwidth.append(kSdpSctpDataChannelString);
   InjectAfter("a=mid:data_content_name\r\n",
               "b=AS:100\r\n",
@@ skipping 714 matching lines @@
       "s=-\r\n"
       "t=0 0\r\n"
       "m=audio 9 RTP/SAVPF 111\r\n"
       "c=IN IP4 0.0.0.0\r\n"
       "a=rtpmap:111 opus/48000/2\r\n"
       "a=msid: track_id\r\n";
 
   JsepSessionDescription jdesc_output(kDummyString);
   EXPECT_FALSE(SdpDeserialize(kSdpWithMissingStreamId, &jdesc_output));
 }