Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(212)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: talk/app/webrtc/webrtcsdp_unittest.cc

Issue 1610243002: Move talk/app/webrtc to webrtc/api (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master
Patch Set: Updated location for peerconnection_unittests.isolate Created 4 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « talk/app/webrtc/webrtcsdp.cc ('k') | talk/app/webrtc/webrtcsession.h » ('j') | talk/libjingle.gyp » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 /*
2 * libjingle
3 * Copyright 2011 Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include <set>
29 #include <string>
30 #include <vector>
31
32 #include "talk/app/webrtc/jsepsessiondescription.h"
33 #ifdef WEBRTC_ANDROID
34 #include "talk/app/webrtc/test/androidtestinitializer.h"
35 #endif
36 #include "talk/app/webrtc/webrtcsdp.h"
37 #include "talk/media/base/constants.h"
38 #include "webrtc/p2p/base/constants.h"
39 #include "talk/session/media/mediasession.h"
40 #include "webrtc/base/gunit.h"
41 #include "webrtc/base/logging.h"
42 #include "webrtc/base/messagedigest.h"
43 #include "webrtc/base/scoped_ptr.h"
44 #include "webrtc/base/sslfingerprint.h"
45 #include "webrtc/base/stringencode.h"
46 #include "webrtc/base/stringutils.h"
47
48 using cricket::AudioCodec;
49 using cricket::AudioContentDescription;
50 using cricket::Candidate;
51 using cricket::ContentInfo;
52 using cricket::CryptoParams;
53 using cricket::ContentGroup;
54 using cricket::DataCodec;
55 using cricket::DataContentDescription;
56 using cricket::ICE_CANDIDATE_COMPONENT_RTCP;
57 using cricket::ICE_CANDIDATE_COMPONENT_RTP;
58 using cricket::kFecSsrcGroupSemantics;
59 using cricket::LOCAL_PORT_TYPE;
60 using cricket::NS_JINGLE_DRAFT_SCTP;
61 using cricket::NS_JINGLE_RTP;
62 using cricket::RtpHeaderExtension;
63 using cricket::RELAY_PORT_TYPE;
64 using cricket::SessionDescription;
65 using cricket::StreamParams;
66 using cricket::STUN_PORT_TYPE;
67 using cricket::TransportDescription;
68 using cricket::TransportInfo;
69 using cricket::VideoCodec;
70 using cricket::VideoContentDescription;
71 using webrtc::IceCandidateCollection;
72 using webrtc::IceCandidateInterface;
73 using webrtc::JsepIceCandidate;
74 using webrtc::JsepSessionDescription;
75 using webrtc::SdpParseError;
76 using webrtc::SessionDescriptionInterface;
77
78 typedef std::vector<AudioCodec> AudioCodecs;
79 typedef std::vector<Candidate> Candidates;
80
81 static const uint32_t kDefaultSctpPort = 5000;
82 static const char kSessionTime[] = "t=0 0\r\n";
83 static const uint32_t kCandidatePriority = 2130706432U; // pref = 1.0
84 static const char kCandidateUfragVoice[] = "ufrag_voice";
85 static const char kCandidatePwdVoice[] = "pwd_voice";
86 static const char kAttributeIceUfragVoice[] = "a=ice-ufrag:ufrag_voice\r\n";
87 static const char kAttributeIcePwdVoice[] = "a=ice-pwd:pwd_voice\r\n";
88 static const char kCandidateUfragVideo[] = "ufrag_video";
89 static const char kCandidatePwdVideo[] = "pwd_video";
90 static const char kCandidateUfragData[] = "ufrag_data";
91 static const char kCandidatePwdData[] = "pwd_data";
92 static const char kAttributeIceUfragVideo[] = "a=ice-ufrag:ufrag_video\r\n";
93 static const char kAttributeIcePwdVideo[] = "a=ice-pwd:pwd_video\r\n";
94 static const uint32_t kCandidateGeneration = 2;
95 static const char kCandidateFoundation1[] = "a0+B/1";
96 static const char kCandidateFoundation2[] = "a0+B/2";
97 static const char kCandidateFoundation3[] = "a0+B/3";
98 static const char kCandidateFoundation4[] = "a0+B/4";
99 static const char kAttributeCryptoVoice[] =
100 "a=crypto:1 AES_CM_128_HMAC_SHA1_32 "
101 "inline:NzB4d1BINUAvLEw6UzF3WSJ+PSdFcGdUJShpX1Zj|2^20|1:32 "
102 "dummy_session_params\r\n";
103 static const char kAttributeCryptoVideo[] =
104 "a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
105 "inline:d0RmdmcmVCspeEc3QGZiNWpVLFJhQX1cfHAwJSoj|2^20|1:32\r\n";
106 static const char kFingerprint[] = "a=fingerprint:sha-1 "
107 "4A:AD:B9:B1:3F:82:18:3B:54:02:12:DF:3E:5D:49:6B:19:E5:7C:AB\r\n";
108 static const int kExtmapId = 1;
109 static const char kExtmapUri[] = "http://example.com/082005/ext.htm#ttime";
110 static const char kExtmap[] =
111 "a=extmap:1 http://example.com/082005/ext.htm#ttime\r\n";
112 static const char kExtmapWithDirectionAndAttribute[] =
113 "a=extmap:1/sendrecv http://example.com/082005/ext.htm#ttime a1 a2\r\n";
114
115 static const uint8_t kIdentityDigest[] = {
116 0x4A, 0xAD, 0xB9, 0xB1, 0x3F, 0x82, 0x18, 0x3B, 0x54, 0x02,
117 0x12, 0xDF, 0x3E, 0x5D, 0x49, 0x6B, 0x19, 0xE5, 0x7C, 0xAB};
118
119 static const char kDtlsSctp[] = "DTLS/SCTP";
120 static const char kUdpDtlsSctp[] = "UDP/DTLS/SCTP";
121 static const char kTcpDtlsSctp[] = "TCP/DTLS/SCTP";
122
123 struct CodecParams {
124 int max_ptime;
125 int ptime;
126 int min_ptime;
127 int sprop_stereo;
128 int stereo;
129 int useinband;
130 int maxaveragebitrate;
131 };
132
133 // Reference sdp string
134 static const char kSdpFullString[] =
135 "v=0\r\n"
136 "o=- 18446744069414584320 18446462598732840960 IN IP4 127.0.0.1\r\n"
137 "s=-\r\n"
138 "t=0 0\r\n"
139 "a=msid-semantic: WMS local_stream_1 local_stream_2\r\n"
140 "m=audio 2345 RTP/SAVPF 111 103 104\r\n"
141 "c=IN IP4 74.125.127.126\r\n"
142 "a=rtcp:2347 IN IP4 74.125.127.126\r\n"
143 "a=candidate:a0+B/1 1 udp 2130706432 192.168.1.5 1234 typ host "
144 "generation 2\r\n"
145 "a=candidate:a0+B/1 2 udp 2130706432 192.168.1.5 1235 typ host "
146 "generation 2\r\n"
147 "a=candidate:a0+B/2 1 udp 2130706432 ::1 1238 typ host "
148 "generation 2\r\n"
149 "a=candidate:a0+B/2 2 udp 2130706432 ::1 1239 typ host "
150 "generation 2\r\n"
151 "a=candidate:a0+B/3 1 udp 2130706432 74.125.127.126 2345 typ srflx "
152 "raddr 192.168.1.5 rport 2346 "
153 "generation 2\r\n"
154 "a=candidate:a0+B/3 2 udp 2130706432 74.125.127.126 2347 typ srflx "
155 "raddr 192.168.1.5 rport 2348 "
156 "generation 2\r\n"
157 "a=ice-ufrag:ufrag_voice\r\na=ice-pwd:pwd_voice\r\n"
158 "a=mid:audio_content_name\r\n"
159 "a=sendrecv\r\n"
160 "a=rtcp-mux\r\n"
161 "a=rtcp-rsize\r\n"
162 "a=crypto:1 AES_CM_128_HMAC_SHA1_32 "
163 "inline:NzB4d1BINUAvLEw6UzF3WSJ+PSdFcGdUJShpX1Zj|2^20|1:32 "
164 "dummy_session_params\r\n"
165 "a=rtpmap:111 opus/48000/2\r\n"
166 "a=rtpmap:103 ISAC/16000\r\n"
167 "a=rtpmap:104 ISAC/32000\r\n"
168 "a=ssrc:1 cname:stream_1_cname\r\n"
169 "a=ssrc:1 msid:local_stream_1 audio_track_id_1\r\n"
170 "a=ssrc:1 mslabel:local_stream_1\r\n"
171 "a=ssrc:1 label:audio_track_id_1\r\n"
172 "a=ssrc:4 cname:stream_2_cname\r\n"
173 "a=ssrc:4 msid:local_stream_2 audio_track_id_2\r\n"
174 "a=ssrc:4 mslabel:local_stream_2\r\n"
175 "a=ssrc:4 label:audio_track_id_2\r\n"
176 "m=video 3457 RTP/SAVPF 120\r\n"
177 "c=IN IP4 74.125.224.39\r\n"
178 "a=rtcp:3456 IN IP4 74.125.224.39\r\n"
179 "a=candidate:a0+B/1 2 udp 2130706432 192.168.1.5 1236 typ host "
180 "generation 2\r\n"
181 "a=candidate:a0+B/1 1 udp 2130706432 192.168.1.5 1237 typ host "
182 "generation 2\r\n"
183 "a=candidate:a0+B/2 2 udp 2130706432 ::1 1240 typ host "
184 "generation 2\r\n"
185 "a=candidate:a0+B/2 1 udp 2130706432 ::1 1241 typ host "
186 "generation 2\r\n"
187 "a=candidate:a0+B/4 2 udp 2130706432 74.125.224.39 3456 typ relay "
188 "generation 2\r\n"
189 "a=candidate:a0+B/4 1 udp 2130706432 74.125.224.39 3457 typ relay "
190 "generation 2\r\n"
191 "a=ice-ufrag:ufrag_video\r\na=ice-pwd:pwd_video\r\n"
192 "a=mid:video_content_name\r\n"
193 "a=sendrecv\r\n"
194 "a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
195 "inline:d0RmdmcmVCspeEc3QGZiNWpVLFJhQX1cfHAwJSoj|2^20|1:32\r\n"
196 "a=rtpmap:120 VP8/90000\r\n"
197 "a=ssrc:2 cname:stream_1_cname\r\n"
198 "a=ssrc:2 msid:local_stream_1 video_track_id_1\r\n"
199 "a=ssrc:2 mslabel:local_stream_1\r\n"
200 "a=ssrc:2 label:video_track_id_1\r\n"
201 "a=ssrc:3 cname:stream_1_cname\r\n"
202 "a=ssrc:3 msid:local_stream_1 video_track_id_2\r\n"
203 "a=ssrc:3 mslabel:local_stream_1\r\n"
204 "a=ssrc:3 label:video_track_id_2\r\n"
205 "a=ssrc-group:FEC 5 6\r\n"
206 "a=ssrc:5 cname:stream_2_cname\r\n"
207 "a=ssrc:5 msid:local_stream_2 video_track_id_3\r\n"
208 "a=ssrc:5 mslabel:local_stream_2\r\n"
209 "a=ssrc:5 label:video_track_id_3\r\n"
210 "a=ssrc:6 cname:stream_2_cname\r\n"
211 "a=ssrc:6 msid:local_stream_2 video_track_id_3\r\n"
212 "a=ssrc:6 mslabel:local_stream_2\r\n"
213 "a=ssrc:6 label:video_track_id_3\r\n";
214
215 // SDP reference string without the candidates.
216 static const char kSdpString[] =
217 "v=0\r\n"
218 "o=- 18446744069414584320 18446462598732840960 IN IP4 127.0.0.1\r\n"
219 "s=-\r\n"
220 "t=0 0\r\n"
221 "a=msid-semantic: WMS local_stream_1 local_stream_2\r\n"
222 "m=audio 9 RTP/SAVPF 111 103 104\r\n"
223 "c=IN IP4 0.0.0.0\r\n"
224 "a=rtcp:9 IN IP4 0.0.0.0\r\n"
225 "a=ice-ufrag:ufrag_voice\r\na=ice-pwd:pwd_voice\r\n"
226 "a=mid:audio_content_name\r\n"
227 "a=sendrecv\r\n"
228 "a=rtcp-mux\r\n"
229 "a=rtcp-rsize\r\n"
230 "a=crypto:1 AES_CM_128_HMAC_SHA1_32 "
231 "inline:NzB4d1BINUAvLEw6UzF3WSJ+PSdFcGdUJShpX1Zj|2^20|1:32 "
232 "dummy_session_params\r\n"
233 "a=rtpmap:111 opus/48000/2\r\n"
234 "a=rtpmap:103 ISAC/16000\r\n"
235 "a=rtpmap:104 ISAC/32000\r\n"
236 "a=ssrc:1 cname:stream_1_cname\r\n"
237 "a=ssrc:1 msid:local_stream_1 audio_track_id_1\r\n"
238 "a=ssrc:1 mslabel:local_stream_1\r\n"
239 "a=ssrc:1 label:audio_track_id_1\r\n"
240 "a=ssrc:4 cname:stream_2_cname\r\n"
241 "a=ssrc:4 msid:local_stream_2 audio_track_id_2\r\n"
242 "a=ssrc:4 mslabel:local_stream_2\r\n"
243 "a=ssrc:4 label:audio_track_id_2\r\n"
244 "m=video 9 RTP/SAVPF 120\r\n"
245 "c=IN IP4 0.0.0.0\r\n"
246 "a=rtcp:9 IN IP4 0.0.0.0\r\n"
247 "a=ice-ufrag:ufrag_video\r\na=ice-pwd:pwd_video\r\n"
248 "a=mid:video_content_name\r\n"
249 "a=sendrecv\r\n"
250 "a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
251 "inline:d0RmdmcmVCspeEc3QGZiNWpVLFJhQX1cfHAwJSoj|2^20|1:32\r\n"
252 "a=rtpmap:120 VP8/90000\r\n"
253 "a=ssrc:2 cname:stream_1_cname\r\n"
254 "a=ssrc:2 msid:local_stream_1 video_track_id_1\r\n"
255 "a=ssrc:2 mslabel:local_stream_1\r\n"
256 "a=ssrc:2 label:video_track_id_1\r\n"
257 "a=ssrc:3 cname:stream_1_cname\r\n"
258 "a=ssrc:3 msid:local_stream_1 video_track_id_2\r\n"
259 "a=ssrc:3 mslabel:local_stream_1\r\n"
260 "a=ssrc:3 label:video_track_id_2\r\n"
261 "a=ssrc-group:FEC 5 6\r\n"
262 "a=ssrc:5 cname:stream_2_cname\r\n"
263 "a=ssrc:5 msid:local_stream_2 video_track_id_3\r\n"
264 "a=ssrc:5 mslabel:local_stream_2\r\n"
265 "a=ssrc:5 label:video_track_id_3\r\n"
266 "a=ssrc:6 cname:stream_2_cname\r\n"
267 "a=ssrc:6 msid:local_stream_2 video_track_id_3\r\n"
268 "a=ssrc:6 mslabel:local_stream_2\r\n"
269 "a=ssrc:6 label:video_track_id_3\r\n";
270
271 static const char kSdpRtpDataChannelString[] =
272 "m=application 9 RTP/SAVPF 101\r\n"
273 "c=IN IP4 0.0.0.0\r\n"
274 "a=rtcp:9 IN IP4 0.0.0.0\r\n"
275 "a=ice-ufrag:ufrag_data\r\n"
276 "a=ice-pwd:pwd_data\r\n"
277 "a=mid:data_content_name\r\n"
278 "a=sendrecv\r\n"
279 "a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
280 "inline:FvLcvU2P3ZWmQxgPAgcDu7Zl9vftYElFOjEzhWs5\r\n"
281 "a=rtpmap:101 google-data/90000\r\n"
282 "a=ssrc:10 cname:data_channel_cname\r\n"
283 "a=ssrc:10 msid:data_channel data_channeld0\r\n"
284 "a=ssrc:10 mslabel:data_channel\r\n"
285 "a=ssrc:10 label:data_channeld0\r\n";
286
287 static const char kSdpSctpDataChannelString[] =
288 "m=application 9 DTLS/SCTP 5000\r\n"
289 "c=IN IP4 0.0.0.0\r\n"
290 "a=ice-ufrag:ufrag_data\r\n"
291 "a=ice-pwd:pwd_data\r\n"
292 "a=mid:data_content_name\r\n"
293 "a=sctpmap:5000 webrtc-datachannel 1024\r\n";
294
295 // draft-ietf-mmusic-sctp-sdp-12
296 static const char kSdpSctpDataChannelStringWithSctpPort[] =
297 "m=application 9 DTLS/SCTP webrtc-datachannel\r\n"
298 "a=max-message-size=100000\r\n"
299 "a=sctp-port 5000\r\n"
300 "c=IN IP4 0.0.0.0\r\n"
301 "a=ice-ufrag:ufrag_data\r\n"
302 "a=ice-pwd:pwd_data\r\n"
303 "a=mid:data_content_name\r\n";
304
305 static const char kSdpSctpDataChannelStringWithSctpColonPort[] =
306 "m=application 9 DTLS/SCTP webrtc-datachannel\r\n"
307 "a=max-message-size=100000\r\n"
308 "a=sctp-port:5000\r\n"
309 "c=IN IP4 0.0.0.0\r\n"
310 "a=ice-ufrag:ufrag_data\r\n"
311 "a=ice-pwd:pwd_data\r\n"
312 "a=mid:data_content_name\r\n";
313
314 static const char kSdpSctpDataChannelWithCandidatesString[] =
315 "m=application 2345 DTLS/SCTP 5000\r\n"
316 "c=IN IP4 74.125.127.126\r\n"
317 "a=candidate:a0+B/1 1 udp 2130706432 192.168.1.5 1234 typ host "
318 "generation 2\r\n"
319 "a=candidate:a0+B/2 1 udp 2130706432 ::1 1238 typ host "
320 "generation 2\r\n"
321 "a=candidate:a0+B/3 1 udp 2130706432 74.125.127.126 2345 typ srflx "
322 "raddr 192.168.1.5 rport 2346 "
323 "generation 2\r\n"
324 "a=ice-ufrag:ufrag_data\r\n"
325 "a=ice-pwd:pwd_data\r\n"
326 "a=mid:data_content_name\r\n"
327 "a=sctpmap:5000 webrtc-datachannel 1024\r\n";
328
329 static const char kSdpConferenceString[] =
330 "v=0\r\n"
331 "o=- 18446744069414584320 18446462598732840960 IN IP4 127.0.0.1\r\n"
332 "s=-\r\n"
333 "t=0 0\r\n"
334 "a=msid-semantic: WMS\r\n"
335 "m=audio 9 RTP/SAVPF 111 103 104\r\n"
336 "c=IN IP4 0.0.0.0\r\n"
337 "a=x-google-flag:conference\r\n"
338 "m=video 9 RTP/SAVPF 120\r\n"
339 "c=IN IP4 0.0.0.0\r\n"
340 "a=x-google-flag:conference\r\n";
341
342 static const char kSdpSessionString[] =
343 "v=0\r\n"
344 "o=- 18446744069414584320 18446462598732840960 IN IP4 127.0.0.1\r\n"
345 "s=-\r\n"
346 "t=0 0\r\n"
347 "a=msid-semantic: WMS local_stream\r\n";
348
349 static const char kSdpAudioString[] =
350 "m=audio 9 RTP/SAVPF 111\r\n"
351 "c=IN IP4 0.0.0.0\r\n"
352 "a=rtcp:9 IN IP4 0.0.0.0\r\n"
353 "a=ice-ufrag:ufrag_voice\r\na=ice-pwd:pwd_voice\r\n"
354 "a=mid:audio_content_name\r\n"
355 "a=sendrecv\r\n"
356 "a=rtpmap:111 opus/48000/2\r\n"
357 "a=ssrc:1 cname:stream_1_cname\r\n"
358 "a=ssrc:1 msid:local_stream audio_track_id_1\r\n"
359 "a=ssrc:1 mslabel:local_stream\r\n"
360 "a=ssrc:1 label:audio_track_id_1\r\n";
361
362 static const char kSdpVideoString[] =
363 "m=video 9 RTP/SAVPF 120\r\n"
364 "c=IN IP4 0.0.0.0\r\n"
365 "a=rtcp:9 IN IP4 0.0.0.0\r\n"
366 "a=ice-ufrag:ufrag_video\r\na=ice-pwd:pwd_video\r\n"
367 "a=mid:video_content_name\r\n"
368 "a=sendrecv\r\n"
369 "a=rtpmap:120 VP8/90000\r\n"
370 "a=ssrc:2 cname:stream_1_cname\r\n"
371 "a=ssrc:2 msid:local_stream video_track_id_1\r\n"
372 "a=ssrc:2 mslabel:local_stream\r\n"
373 "a=ssrc:2 label:video_track_id_1\r\n";
374
375
376 // One candidate reference string as per W3c spec.
377 // candidate:<blah> not a=candidate:<blah>CRLF
378 static const char kRawCandidate[] =
379 "candidate:a0+B/1 1 udp 2130706432 192.168.1.5 1234 typ host generation 2";
380 // One candidate reference string.
381 static const char kSdpOneCandidate[] =
382 "a=candidate:a0+B/1 1 udp 2130706432 192.168.1.5 1234 typ host "
383 "generation 2\r\n";
384
385 static const char kSdpTcpActiveCandidate[] =
386 "candidate:a0+B/1 1 tcp 2130706432 192.168.1.5 9 typ host "
387 "tcptype active generation 2";
388 static const char kSdpTcpPassiveCandidate[] =
389 "candidate:a0+B/1 1 tcp 2130706432 192.168.1.5 9 typ host "
390 "tcptype passive generation 2";
391 static const char kSdpTcpSOCandidate[] =
392 "candidate:a0+B/1 1 tcp 2130706432 192.168.1.5 9 typ host "
393 "tcptype so generation 2";
394 static const char kSdpTcpInvalidCandidate[] =
395 "candidate:a0+B/1 1 tcp 2130706432 192.168.1.5 9 typ host "
396 "tcptype invalid generation 2";
397
398 // One candidate reference string with IPV6 address.
399 static const char kRawIPV6Candidate[] =
400 "candidate:a0+B/1 1 udp 2130706432 "
401 "abcd::abcd::abcd::abcd::abcd::abcd::abcd::abcd 1234 typ host generation 2";
402
403 // One candidate reference string.
404 static const char kSdpOneCandidateWithUfragPwd[] =
405 "a=candidate:a0+B/1 1 udp 2130706432 192.168.1.5 1234 typ host network_name"
406 " eth0 ufrag user_rtp pwd password_rtp generation 2\r\n";
407
408 // Session id and version
409 static const char kSessionId[] = "18446744069414584320";
410 static const char kSessionVersion[] = "18446462598732840960";
411
412 // Ice options
413 static const char kIceOption1[] = "iceoption1";
414 static const char kIceOption2[] = "iceoption2";
415 static const char kIceOption3[] = "iceoption3";
416
417 // Content name
418 static const char kAudioContentName[] = "audio_content_name";
419 static const char kVideoContentName[] = "video_content_name";
420 static const char kDataContentName[] = "data_content_name";
421
422 // MediaStream 1
423 static const char kStreamLabel1[] = "local_stream_1";
424 static const char kStream1Cname[] = "stream_1_cname";
425 static const char kAudioTrackId1[] = "audio_track_id_1";
426 static const uint32_t kAudioTrack1Ssrc = 1;
427 static const char kVideoTrackId1[] = "video_track_id_1";
428 static const uint32_t kVideoTrack1Ssrc = 2;
429 static const char kVideoTrackId2[] = "video_track_id_2";
430 static const uint32_t kVideoTrack2Ssrc = 3;
431
432 // MediaStream 2
433 static const char kStreamLabel2[] = "local_stream_2";
434 static const char kStream2Cname[] = "stream_2_cname";
435 static const char kAudioTrackId2[] = "audio_track_id_2";
436 static const uint32_t kAudioTrack2Ssrc = 4;
437 static const char kVideoTrackId3[] = "video_track_id_3";
438 static const uint32_t kVideoTrack3Ssrc = 5;
439 static const uint32_t kVideoTrack4Ssrc = 6;
440
441 // DataChannel
442 static const char kDataChannelLabel[] = "data_channel";
443 static const char kDataChannelMsid[] = "data_channeld0";
444 static const char kDataChannelCname[] = "data_channel_cname";
445 static const uint32_t kDataChannelSsrc = 10;
446
447 // Candidate
448 static const char kDummyMid[] = "dummy_mid";
449 static const int kDummyIndex = 123;
450
451 // Misc
452 static const char kDummyString[] = "dummy";
453
454 // Helper functions
455
456 static bool SdpDeserialize(const std::string& message,
457 JsepSessionDescription* jdesc) {
458 return webrtc::SdpDeserialize(message, jdesc, NULL);
459 }
460
461 static bool SdpDeserializeCandidate(const std::string& message,
462 JsepIceCandidate* candidate) {
463 return webrtc::SdpDeserializeCandidate(message, candidate, NULL);
464 }
465
466 // Add some extra |newlines| to the |message| after |line|.
467 static void InjectAfter(const std::string& line,
468 const std::string& newlines,
469 std::string* message) {
470 const std::string tmp = line + newlines;
471 rtc::replace_substrs(line.c_str(), line.length(),
472 tmp.c_str(), tmp.length(), message);
473 }
474
475 static void Replace(const std::string& line,
476 const std::string& newlines,
477 std::string* message) {
478 rtc::replace_substrs(line.c_str(), line.length(),
479 newlines.c_str(), newlines.length(), message);
480 }
481
482 // Expect fail to parase |bad_sdp| and expect |bad_part| be part of the error
483 // message.
484 static void ExpectParseFailure(const std::string& bad_sdp,
485 const std::string& bad_part) {
486 JsepSessionDescription desc(kDummyString);
487 SdpParseError error;
488 bool ret = webrtc::SdpDeserialize(bad_sdp, &desc, &error);
489 EXPECT_FALSE(ret);
490 EXPECT_NE(std::string::npos, error.line.find(bad_part.c_str()));
491 }
492
493 // Expect fail to parse kSdpFullString if replace |good_part| with |bad_part|.
494 static void ExpectParseFailure(const char* good_part, const char* bad_part) {
495 std::string bad_sdp = kSdpFullString;
496 Replace(good_part, bad_part, &bad_sdp);
497 ExpectParseFailure(bad_sdp, bad_part);
498 }
499
500 // Expect fail to parse kSdpFullString if add |newlines| after |injectpoint|.
501 static void ExpectParseFailureWithNewLines(const std::string& injectpoint,
502 const std::string& newlines,
503 const std::string& bad_part) {
504 std::string bad_sdp = kSdpFullString;
505 InjectAfter(injectpoint, newlines, &bad_sdp);
506 ExpectParseFailure(bad_sdp, bad_part);
507 }
508
509 static void ReplaceDirection(cricket::MediaContentDirection direction,
510 std::string* message) {
511 std::string new_direction;
512 switch (direction) {
513 case cricket::MD_INACTIVE:
514 new_direction = "a=inactive";
515 break;
516 case cricket::MD_SENDONLY:
517 new_direction = "a=sendonly";
518 break;
519 case cricket::MD_RECVONLY:
520 new_direction = "a=recvonly";
521 break;
522 case cricket::MD_SENDRECV:
523 default:
524 new_direction = "a=sendrecv";
525 break;
526 }
527 Replace("a=sendrecv", new_direction, message);
528 }
529
530 static void ReplaceRejected(bool audio_rejected, bool video_rejected,
531 std::string* message) {
532 if (audio_rejected) {
533 Replace("m=audio 9", "m=audio 0", message);
534 Replace(kAttributeIceUfragVoice, "", message);
535 Replace(kAttributeIcePwdVoice, "", message);
536 }
537 if (video_rejected) {
538 Replace("m=video 9", "m=video 0", message);
539 Replace(kAttributeIceUfragVideo, "", message);
540 Replace(kAttributeIcePwdVideo, "", message);
541 }
542 }
543
544 // WebRtcSdpTest
545
546 class WebRtcSdpTest : public testing::Test {
547 public:
548 WebRtcSdpTest()
549 : jdesc_(kDummyString) {
550 #ifdef WEBRTC_ANDROID
551 webrtc::InitializeAndroidObjects();
552 #endif
553 // AudioContentDescription
554 audio_desc_ = CreateAudioContentDescription();
555 AudioCodec opus(111, "opus", 48000, 0, 2, 3);
556 audio_desc_->AddCodec(opus);
557 audio_desc_->AddCodec(AudioCodec(103, "ISAC", 16000, 32000, 1, 2));
558 audio_desc_->AddCodec(AudioCodec(104, "ISAC", 32000, 56000, 1, 1));
559 desc_.AddContent(kAudioContentName, NS_JINGLE_RTP, audio_desc_);
560
561 // VideoContentDescription
562 rtc::scoped_ptr<VideoContentDescription> video(
563 new VideoContentDescription());
564 video_desc_ = video.get();
565 StreamParams video_stream1;
566 video_stream1.id = kVideoTrackId1;
567 video_stream1.cname = kStream1Cname;
568 video_stream1.sync_label = kStreamLabel1;
569 video_stream1.ssrcs.push_back(kVideoTrack1Ssrc);
570 video->AddStream(video_stream1);
571 StreamParams video_stream2;
572 video_stream2.id = kVideoTrackId2;
573 video_stream2.cname = kStream1Cname;
574 video_stream2.sync_label = kStreamLabel1;
575 video_stream2.ssrcs.push_back(kVideoTrack2Ssrc);
576 video->AddStream(video_stream2);
577 StreamParams video_stream3;
578 video_stream3.id = kVideoTrackId3;
579 video_stream3.cname = kStream2Cname;
580 video_stream3.sync_label = kStreamLabel2;
581 video_stream3.ssrcs.push_back(kVideoTrack3Ssrc);
582 video_stream3.ssrcs.push_back(kVideoTrack4Ssrc);
583 cricket::SsrcGroup ssrc_group(kFecSsrcGroupSemantics, video_stream3.ssrcs);
584 video_stream3.ssrc_groups.push_back(ssrc_group);
585 video->AddStream(video_stream3);
586 video->AddCrypto(CryptoParams(1, "AES_CM_128_HMAC_SHA1_80",
587 "inline:d0RmdmcmVCspeEc3QGZiNWpVLFJhQX1cfHAwJSoj|2^20|1:32", ""));
588 video->set_protocol(cricket::kMediaProtocolSavpf);
589 video->AddCodec(VideoCodec(
590 120,
591 JsepSessionDescription::kDefaultVideoCodecName,
592 JsepSessionDescription::kMaxVideoCodecWidth,
593 JsepSessionDescription::kMaxVideoCodecHeight,
594 JsepSessionDescription::kDefaultVideoCodecFramerate,
595 JsepSessionDescription::kDefaultVideoCodecPreference));
596
597 desc_.AddContent(kVideoContentName, NS_JINGLE_RTP,
598 video.release());
599
600 // TransportInfo
601 EXPECT_TRUE(desc_.AddTransportInfo(
602 TransportInfo(kAudioContentName,
603 TransportDescription(kCandidateUfragVoice,
604 kCandidatePwdVoice))));
605 EXPECT_TRUE(desc_.AddTransportInfo(
606 TransportInfo(kVideoContentName,
607 TransportDescription(kCandidateUfragVideo,
608 kCandidatePwdVideo))));
609
610 // v4 host
611 int port = 1234;
612 rtc::SocketAddress address("192.168.1.5", port++);
613 Candidate candidate1(ICE_CANDIDATE_COMPONENT_RTP, "udp", address,
614 kCandidatePriority, "", "", LOCAL_PORT_TYPE,
615 kCandidateGeneration, kCandidateFoundation1);
616 address.SetPort(port++);
617 Candidate candidate2(ICE_CANDIDATE_COMPONENT_RTCP, "udp", address,
618 kCandidatePriority, "", "", LOCAL_PORT_TYPE,
619 kCandidateGeneration, kCandidateFoundation1);
620 address.SetPort(port++);
621 Candidate candidate3(ICE_CANDIDATE_COMPONENT_RTCP, "udp", address,
622 kCandidatePriority, "", "", LOCAL_PORT_TYPE,
623 kCandidateGeneration, kCandidateFoundation1);
624 address.SetPort(port++);
625 Candidate candidate4(ICE_CANDIDATE_COMPONENT_RTP, "udp", address,
626 kCandidatePriority, "", "", LOCAL_PORT_TYPE,
627 kCandidateGeneration, kCandidateFoundation1);
628
629 // v6 host
630 rtc::SocketAddress v6_address("::1", port++);
631 cricket::Candidate candidate5(cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
632 v6_address, kCandidatePriority, "", "",
633 cricket::LOCAL_PORT_TYPE,
634 kCandidateGeneration, kCandidateFoundation2);
635 v6_address.SetPort(port++);
636 cricket::Candidate candidate6(cricket::ICE_CANDIDATE_COMPONENT_RTCP, "udp",
637 v6_address, kCandidatePriority, "", "",
638 cricket::LOCAL_PORT_TYPE,
639 kCandidateGeneration, kCandidateFoundation2);
640 v6_address.SetPort(port++);
641 cricket::Candidate candidate7(cricket::ICE_CANDIDATE_COMPONENT_RTCP, "udp",
642 v6_address, kCandidatePriority, "", "",
643 cricket::LOCAL_PORT_TYPE,
644 kCandidateGeneration, kCandidateFoundation2);
645 v6_address.SetPort(port++);
646 cricket::Candidate candidate8(cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
647 v6_address, kCandidatePriority, "", "",
648 cricket::LOCAL_PORT_TYPE,
649 kCandidateGeneration, kCandidateFoundation2);
650
651 // stun
652 int port_stun = 2345;
653 rtc::SocketAddress address_stun("74.125.127.126", port_stun++);
654 rtc::SocketAddress rel_address_stun("192.168.1.5", port_stun++);
655 cricket::Candidate candidate9(cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
656 address_stun, kCandidatePriority, "", "",
657 STUN_PORT_TYPE, kCandidateGeneration,
658 kCandidateFoundation3);
659 candidate9.set_related_address(rel_address_stun);
660
661 address_stun.SetPort(port_stun++);
662 rel_address_stun.SetPort(port_stun++);
663 cricket::Candidate candidate10(cricket::ICE_CANDIDATE_COMPONENT_RTCP, "udp",
664 address_stun, kCandidatePriority, "", "",
665 STUN_PORT_TYPE, kCandidateGeneration,
666 kCandidateFoundation3);
667 candidate10.set_related_address(rel_address_stun);
668
669 // relay
670 int port_relay = 3456;
671 rtc::SocketAddress address_relay("74.125.224.39", port_relay++);
672 cricket::Candidate candidate11(cricket::ICE_CANDIDATE_COMPONENT_RTCP, "udp",
673 address_relay, kCandidatePriority, "", "",
674 cricket::RELAY_PORT_TYPE,
675 kCandidateGeneration, kCandidateFoundation4);
676 address_relay.SetPort(port_relay++);
677 cricket::Candidate candidate12(cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
678 address_relay, kCandidatePriority, "", "",
679 RELAY_PORT_TYPE, kCandidateGeneration,
680 kCandidateFoundation4);
681
682 // voice
683 candidates_.push_back(candidate1);
684 candidates_.push_back(candidate2);
685 candidates_.push_back(candidate5);
686 candidates_.push_back(candidate6);
687 candidates_.push_back(candidate9);
688 candidates_.push_back(candidate10);
689
690 // video
691 candidates_.push_back(candidate3);
692 candidates_.push_back(candidate4);
693 candidates_.push_back(candidate7);
694 candidates_.push_back(candidate8);
695 candidates_.push_back(candidate11);
696 candidates_.push_back(candidate12);
697
698 jcandidate_.reset(new JsepIceCandidate(std::string("audio_content_name"),
699 0, candidate1));
700
701 // Set up JsepSessionDescription.
702 jdesc_.Initialize(desc_.Copy(), kSessionId, kSessionVersion);
703 std::string mline_id;
704 int mline_index = 0;
705 for (size_t i = 0; i< candidates_.size(); ++i) {
706 // In this test, the audio m line index will be 0, and the video m line
707 // will be 1.
708 bool is_video = (i > 5);
709 mline_id = is_video ? "video_content_name" : "audio_content_name";
710 mline_index = is_video ? 1 : 0;
711 JsepIceCandidate jice(mline_id,
712 mline_index,
713 candidates_.at(i));
714 jdesc_.AddCandidate(&jice);
715 }
716 }
717
718 AudioContentDescription* CreateAudioContentDescription() {
719 AudioContentDescription* audio = new AudioContentDescription();
720 audio->set_rtcp_mux(true);
721 audio->set_rtcp_reduced_size(true);
722 StreamParams audio_stream1;
723 audio_stream1.id = kAudioTrackId1;
724 audio_stream1.cname = kStream1Cname;
725 audio_stream1.sync_label = kStreamLabel1;
726 audio_stream1.ssrcs.push_back(kAudioTrack1Ssrc);
727 audio->AddStream(audio_stream1);
728 StreamParams audio_stream2;
729 audio_stream2.id = kAudioTrackId2;
730 audio_stream2.cname = kStream2Cname;
731 audio_stream2.sync_label = kStreamLabel2;
732 audio_stream2.ssrcs.push_back(kAudioTrack2Ssrc);
733 audio->AddStream(audio_stream2);
734 audio->AddCrypto(CryptoParams(1, "AES_CM_128_HMAC_SHA1_32",
735 "inline:NzB4d1BINUAvLEw6UzF3WSJ+PSdFcGdUJShpX1Zj|2^20|1:32",
736 "dummy_session_params"));
737 audio->set_protocol(cricket::kMediaProtocolSavpf);
738 return audio;
739 }
740
741 template <class MCD>
742 void CompareMediaContentDescription(const MCD* cd1,
743 const MCD* cd2) {
744 // type
745 EXPECT_EQ(cd1->type(), cd1->type());
746
747 // content direction
748 EXPECT_EQ(cd1->direction(), cd2->direction());
749
750 // rtcp_mux
751 EXPECT_EQ(cd1->rtcp_mux(), cd2->rtcp_mux());
752
753 // rtcp_reduced_size
754 EXPECT_EQ(cd1->rtcp_reduced_size(), cd2->rtcp_reduced_size());
755
756 // cryptos
757 EXPECT_EQ(cd1->cryptos().size(), cd2->cryptos().size());
758 if (cd1->cryptos().size() != cd2->cryptos().size()) {
759 ADD_FAILURE();
760 return;
761 }
762 for (size_t i = 0; i< cd1->cryptos().size(); ++i) {
763 const CryptoParams c1 = cd1->cryptos().at(i);
764 const CryptoParams c2 = cd2->cryptos().at(i);
765 EXPECT_TRUE(c1.Matches(c2));
766 EXPECT_EQ(c1.key_params, c2.key_params);
767 EXPECT_EQ(c1.session_params, c2.session_params);
768 }
769
770 // protocol
771 // Use an equivalence class here, for old and new versions of the
772 // protocol description.
773 if (cd1->protocol() == cricket::kMediaProtocolDtlsSctp
774 || cd1->protocol() == cricket::kMediaProtocolUdpDtlsSctp
775 || cd1->protocol() == cricket::kMediaProtocolTcpDtlsSctp) {
776 const bool cd2_is_also_dtls_sctp =
777 cd2->protocol() == cricket::kMediaProtocolDtlsSctp
778 || cd2->protocol() == cricket::kMediaProtocolUdpDtlsSctp
779 || cd2->protocol() == cricket::kMediaProtocolTcpDtlsSctp;
780 EXPECT_TRUE(cd2_is_also_dtls_sctp);
781 } else {
782 EXPECT_EQ(cd1->protocol(), cd2->protocol());
783 }
784
785 // codecs
786 EXPECT_EQ(cd1->codecs(), cd2->codecs());
787
788 // bandwidth
789 EXPECT_EQ(cd1->bandwidth(), cd2->bandwidth());
790
791 // streams
792 EXPECT_EQ(cd1->streams(), cd2->streams());
793
794 // extmap
795 ASSERT_EQ(cd1->rtp_header_extensions().size(),
796 cd2->rtp_header_extensions().size());
797 for (size_t i = 0; i< cd1->rtp_header_extensions().size(); ++i) {
798 const RtpHeaderExtension ext1 = cd1->rtp_header_extensions().at(i);
799 const RtpHeaderExtension ext2 = cd2->rtp_header_extensions().at(i);
800 EXPECT_EQ(ext1.uri, ext2.uri);
801 EXPECT_EQ(ext1.id, ext2.id);
802 }
803 }
804
805
806 void CompareSessionDescription(const SessionDescription& desc1,
807 const SessionDescription& desc2) {
808 // Compare content descriptions.
809 if (desc1.contents().size() != desc2.contents().size()) {
810 ADD_FAILURE();
811 return;
812 }
813 for (size_t i = 0 ; i < desc1.contents().size(); ++i) {
814 const cricket::ContentInfo& c1 = desc1.contents().at(i);
815 const cricket::ContentInfo& c2 = desc2.contents().at(i);
816 // content name
817 EXPECT_EQ(c1.name, c2.name);
818 // content type
819 // Note, ASSERT will return from the function, but will not stop the test.
820 ASSERT_EQ(c1.type, c2.type);
821
822 ASSERT_EQ(IsAudioContent(&c1), IsAudioContent(&c2));
823 if (IsAudioContent(&c1)) {
824 const AudioContentDescription* acd1 =
825 static_cast<const AudioContentDescription*>(c1.description);
826 const AudioContentDescription* acd2 =
827 static_cast<const AudioContentDescription*>(c2.description);
828 CompareMediaContentDescription<AudioContentDescription>(acd1, acd2);
829 }
830
831 ASSERT_EQ(IsVideoContent(&c1), IsVideoContent(&c2));
832 if (IsVideoContent(&c1)) {
833 const VideoContentDescription* vcd1 =
834 static_cast<const VideoContentDescription*>(c1.description);
835 const VideoContentDescription* vcd2 =
836 static_cast<const VideoContentDescription*>(c2.description);
837 CompareMediaContentDescription<VideoContentDescription>(vcd1, vcd2);
838 }
839
840 ASSERT_EQ(IsDataContent(&c1), IsDataContent(&c2));
841 if (IsDataContent(&c1)) {
842 const DataContentDescription* dcd1 =
843 static_cast<const DataContentDescription*>(c1.description);
844 const DataContentDescription* dcd2 =
845 static_cast<const DataContentDescription*>(c2.description);
846 CompareMediaContentDescription<DataContentDescription>(dcd1, dcd2);
847 }
848 }
849
850 // group
851 const cricket::ContentGroups groups1 = desc1.groups();
852 const cricket::ContentGroups groups2 = desc2.groups();
853 EXPECT_EQ(groups1.size(), groups1.size());
854 if (groups1.size() != groups2.size()) {
855 ADD_FAILURE();
856 return;
857 }
858 for (size_t i = 0; i < groups1.size(); ++i) {
859 const cricket::ContentGroup group1 = groups1.at(i);
860 const cricket::ContentGroup group2 = groups2.at(i);
861 EXPECT_EQ(group1.semantics(), group2.semantics());
862 const cricket::ContentNames names1 = group1.content_names();
863 const cricket::ContentNames names2 = group2.content_names();
864 EXPECT_EQ(names1.size(), names2.size());
865 if (names1.size() != names2.size()) {
866 ADD_FAILURE();
867 return;
868 }
869 cricket::ContentNames::const_iterator iter1 = names1.begin();
870 cricket::ContentNames::const_iterator iter2 = names2.begin();
871 while (iter1 != names1.end()) {
872 EXPECT_EQ(*iter1++, *iter2++);
873 }
874 }
875
876 // transport info
877 const cricket::TransportInfos transports1 = desc1.transport_infos();
878 const cricket::TransportInfos transports2 = desc2.transport_infos();
879 EXPECT_EQ(transports1.size(), transports2.size());
880 if (transports1.size() != transports2.size()) {
881 ADD_FAILURE();
882 return;
883 }
884 for (size_t i = 0; i < transports1.size(); ++i) {
885 const cricket::TransportInfo transport1 = transports1.at(i);
886 const cricket::TransportInfo transport2 = transports2.at(i);
887 EXPECT_EQ(transport1.content_name, transport2.content_name);
888 EXPECT_EQ(transport1.description.ice_ufrag,
889 transport2.description.ice_ufrag);
890 EXPECT_EQ(transport1.description.ice_pwd,
891 transport2.description.ice_pwd);
892 if (transport1.description.identity_fingerprint) {
893 EXPECT_EQ(*transport1.description.identity_fingerprint,
894 *transport2.description.identity_fingerprint);
895 } else {
896 EXPECT_EQ(transport1.description.identity_fingerprint.get(),
897 transport2.description.identity_fingerprint.get());
898 }
899 EXPECT_EQ(transport1.description.transport_options,
900 transport2.description.transport_options);
901 EXPECT_TRUE(CompareCandidates(transport1.description.candidates,
902 transport2.description.candidates));
903 }
904
905 // global attributes
906 EXPECT_EQ(desc1.msid_supported(), desc2.msid_supported());
907 }
908
909 bool CompareCandidates(const Candidates& cs1, const Candidates& cs2) {
910 EXPECT_EQ(cs1.size(), cs2.size());
911 if (cs1.size() != cs2.size())
912 return false;
913 for (size_t i = 0; i< cs1.size(); ++i) {
914 const Candidate c1 = cs1.at(i);
915 const Candidate c2 = cs2.at(i);
916 EXPECT_TRUE(c1.IsEquivalent(c2));
917 }
918 return true;
919 }
920
921 bool CompareSessionDescription(
922 const JsepSessionDescription& desc1,
923 const JsepSessionDescription& desc2) {
924 EXPECT_EQ(desc1.session_id(), desc2.session_id());
925 EXPECT_EQ(desc1.session_version(), desc2.session_version());
926 CompareSessionDescription(*desc1.description(), *desc2.description());
927 if (desc1.number_of_mediasections() != desc2.number_of_mediasections())
928 return false;
929 for (size_t i = 0; i < desc1.number_of_mediasections(); ++i) {
930 const IceCandidateCollection* cc1 = desc1.candidates(i);
931 const IceCandidateCollection* cc2 = desc2.candidates(i);
932 if (cc1->count() != cc2->count())
933 return false;
934 for (size_t j = 0; j < cc1->count(); ++j) {
935 const IceCandidateInterface* c1 = cc1->at(j);
936 const IceCandidateInterface* c2 = cc2->at(j);
937 EXPECT_EQ(c1->sdp_mid(), c2->sdp_mid());
938 EXPECT_EQ(c1->sdp_mline_index(), c2->sdp_mline_index());
939 EXPECT_TRUE(c1->candidate().IsEquivalent(c2->candidate()));
940 }
941 }
942 return true;
943 }
944
945 // Disable the ice-ufrag and ice-pwd in given |sdp| message by replacing
946 // them with invalid keywords so that the parser will just ignore them.
947 bool RemoveCandidateUfragPwd(std::string* sdp) {
948 const char ice_ufrag[] = "a=ice-ufrag";
949 const char ice_ufragx[] = "a=xice-ufrag";
950 const char ice_pwd[] = "a=ice-pwd";
951 const char ice_pwdx[] = "a=xice-pwd";
952 rtc::replace_substrs(ice_ufrag, strlen(ice_ufrag),
953 ice_ufragx, strlen(ice_ufragx), sdp);
954 rtc::replace_substrs(ice_pwd, strlen(ice_pwd),
955 ice_pwdx, strlen(ice_pwdx), sdp);
956 return true;
957 }
958
959 // Update the candidates in |jdesc| to use the given |ufrag| and |pwd|.
960 bool UpdateCandidateUfragPwd(JsepSessionDescription* jdesc, int mline_index,
961 const std::string& ufrag, const std::string& pwd) {
962 std::string content_name;
963 if (mline_index == 0) {
964 content_name = kAudioContentName;
965 } else if (mline_index == 1) {
966 content_name = kVideoContentName;
967 } else {
968 ASSERT(false);
969 }
970 TransportInfo transport_info(
971 content_name, TransportDescription(ufrag, pwd));
972 SessionDescription* desc =
973 const_cast<SessionDescription*>(jdesc->description());
974 desc->RemoveTransportInfoByName(content_name);
975 EXPECT_TRUE(desc->AddTransportInfo(transport_info));
976 for (size_t i = 0; i < jdesc_.number_of_mediasections(); ++i) {
977 const IceCandidateCollection* cc = jdesc_.candidates(i);
978 for (size_t j = 0; j < cc->count(); ++j) {
979 if (cc->at(j)->sdp_mline_index() == mline_index) {
980 const_cast<Candidate&>(cc->at(j)->candidate()).set_username(
981 ufrag);
982 const_cast<Candidate&>(cc->at(j)->candidate()).set_password(
983 pwd);
984 }
985 }
986 }
987 return true;
988 }
989
990 void AddIceOptions(const std::string& content_name,
991 const std::vector<std::string>& transport_options) {
992 ASSERT_TRUE(desc_.GetTransportInfoByName(content_name) != NULL);
993 cricket::TransportInfo transport_info =
994 *(desc_.GetTransportInfoByName(content_name));
995 desc_.RemoveTransportInfoByName(content_name);
996 transport_info.description.transport_options = transport_options;
997 desc_.AddTransportInfo(transport_info);
998 }
999
1000 void SetIceUfragPwd(const std::string& content_name,
1001 const std::string& ice_ufrag,
1002 const std::string& ice_pwd) {
1003 ASSERT_TRUE(desc_.GetTransportInfoByName(content_name) != NULL);
1004 cricket::TransportInfo transport_info =
1005 *(desc_.GetTransportInfoByName(content_name));
1006 desc_.RemoveTransportInfoByName(content_name);
1007 transport_info.description.ice_ufrag = ice_ufrag;
1008 transport_info.description.ice_pwd = ice_pwd;
1009 desc_.AddTransportInfo(transport_info);
1010 }
1011
1012 void AddFingerprint() {
1013 desc_.RemoveTransportInfoByName(kAudioContentName);
1014 desc_.RemoveTransportInfoByName(kVideoContentName);
1015 rtc::SSLFingerprint fingerprint(rtc::DIGEST_SHA_1,
1016 kIdentityDigest,
1017 sizeof(kIdentityDigest));
1018 EXPECT_TRUE(desc_.AddTransportInfo(
1019 TransportInfo(kAudioContentName,
1020 TransportDescription(std::vector<std::string>(),
1021 kCandidateUfragVoice,
1022 kCandidatePwdVoice,
1023 cricket::ICEMODE_FULL,
1024 cricket::CONNECTIONROLE_NONE,
1025 &fingerprint, Candidates()))));
1026 EXPECT_TRUE(desc_.AddTransportInfo(
1027 TransportInfo(kVideoContentName,
1028 TransportDescription(std::vector<std::string>(),
1029 kCandidateUfragVideo,
1030 kCandidatePwdVideo,
1031 cricket::ICEMODE_FULL,
1032 cricket::CONNECTIONROLE_NONE,
1033 &fingerprint, Candidates()))));
1034 }
1035
1036 void AddExtmap() {
1037 audio_desc_ = static_cast<AudioContentDescription*>(
1038 audio_desc_->Copy());
1039 video_desc_ = static_cast<VideoContentDescription*>(
1040 video_desc_->Copy());
1041 audio_desc_->AddRtpHeaderExtension(
1042 RtpHeaderExtension(kExtmapUri, kExtmapId));
1043 video_desc_->AddRtpHeaderExtension(
1044 RtpHeaderExtension(kExtmapUri, kExtmapId));
1045 desc_.RemoveContentByName(kAudioContentName);
1046 desc_.RemoveContentByName(kVideoContentName);
1047 desc_.AddContent(kAudioContentName, NS_JINGLE_RTP, audio_desc_);
1048 desc_.AddContent(kVideoContentName, NS_JINGLE_RTP, video_desc_);
1049 }
1050
1051 void RemoveCryptos() {
1052 audio_desc_->set_cryptos(std::vector<CryptoParams>());
1053 video_desc_->set_cryptos(std::vector<CryptoParams>());
1054 }
1055
1056 bool TestSerializeDirection(cricket::MediaContentDirection direction) {
1057 audio_desc_->set_direction(direction);
1058 video_desc_->set_direction(direction);
1059 std::string new_sdp = kSdpFullString;
1060 ReplaceDirection(direction, &new_sdp);
1061
1062 if (!jdesc_.Initialize(desc_.Copy(),
1063 jdesc_.session_id(),
1064 jdesc_.session_version())) {
1065 return false;
1066 }
1067 std::string message = webrtc::SdpSerialize(jdesc_);
1068 EXPECT_EQ(new_sdp, message);
1069 return true;
1070 }
1071
1072 bool TestSerializeRejected(bool audio_rejected, bool video_rejected) {
1073 audio_desc_ = static_cast<AudioContentDescription*>(
1074 audio_desc_->Copy());
1075 video_desc_ = static_cast<VideoContentDescription*>(
1076 video_desc_->Copy());
1077 desc_.RemoveContentByName(kAudioContentName);
1078 desc_.RemoveContentByName(kVideoContentName);
1079 desc_.AddContent(kAudioContentName, NS_JINGLE_RTP, audio_rejected,
1080 audio_desc_);
1081 desc_.AddContent(kVideoContentName, NS_JINGLE_RTP, video_rejected,
1082 video_desc_);
1083 SetIceUfragPwd(kAudioContentName,
1084 audio_rejected ? "" : kCandidateUfragVoice,
1085 audio_rejected ? "" : kCandidatePwdVoice);
1086 SetIceUfragPwd(kVideoContentName,
1087 video_rejected ? "" : kCandidateUfragVideo,
1088 video_rejected ? "" : kCandidatePwdVideo);
1089
1090 std::string new_sdp = kSdpString;
1091 ReplaceRejected(audio_rejected, video_rejected, &new_sdp);
1092
1093 JsepSessionDescription jdesc_no_candidates(kDummyString);
1094 if (!jdesc_no_candidates.Initialize(desc_.Copy(), kSessionId,
1095 kSessionVersion)) {
1096 return false;
1097 }
1098 std::string message = webrtc::SdpSerialize(jdesc_no_candidates);
1099 EXPECT_EQ(new_sdp, message);
1100 return true;
1101 }
1102
1103 void AddSctpDataChannel() {
1104 rtc::scoped_ptr<DataContentDescription> data(
1105 new DataContentDescription());
1106 data_desc_ = data.get();
1107 data_desc_->set_protocol(cricket::kMediaProtocolDtlsSctp);
1108 DataCodec codec(cricket::kGoogleSctpDataCodecId,
1109 cricket::kGoogleSctpDataCodecName, 0);
1110 codec.SetParam(cricket::kCodecParamPort, kDefaultSctpPort);
1111 data_desc_->AddCodec(codec);
1112 desc_.AddContent(kDataContentName, NS_JINGLE_DRAFT_SCTP, data.release());
1113 EXPECT_TRUE(desc_.AddTransportInfo(
1114 TransportInfo(kDataContentName,
1115 TransportDescription(kCandidateUfragData,
1116 kCandidatePwdData))));
1117 }
1118
1119 void AddRtpDataChannel() {
1120 rtc::scoped_ptr<DataContentDescription> data(
1121 new DataContentDescription());
1122 data_desc_ = data.get();
1123
1124 data_desc_->AddCodec(DataCodec(101, "google-data", 1));
1125 StreamParams data_stream;
1126 data_stream.id = kDataChannelMsid;
1127 data_stream.cname = kDataChannelCname;
1128 data_stream.sync_label = kDataChannelLabel;
1129 data_stream.ssrcs.push_back(kDataChannelSsrc);
1130 data_desc_->AddStream(data_stream);
1131 data_desc_->AddCrypto(CryptoParams(
1132 1, "AES_CM_128_HMAC_SHA1_80",
1133 "inline:FvLcvU2P3ZWmQxgPAgcDu7Zl9vftYElFOjEzhWs5", ""));
1134 data_desc_->set_protocol(cricket::kMediaProtocolSavpf);
1135 desc_.AddContent(kDataContentName, NS_JINGLE_RTP, data.release());
1136 EXPECT_TRUE(desc_.AddTransportInfo(
1137 TransportInfo(kDataContentName,
1138 TransportDescription(kCandidateUfragData,
1139 kCandidatePwdData))));
1140 }
1141
1142 bool TestDeserializeDirection(cricket::MediaContentDirection direction) {
1143 std::string new_sdp = kSdpFullString;
1144 ReplaceDirection(direction, &new_sdp);
1145 JsepSessionDescription new_jdesc(kDummyString);
1146
1147 EXPECT_TRUE(SdpDeserialize(new_sdp, &new_jdesc));
1148
1149 audio_desc_->set_direction(direction);
1150 video_desc_->set_direction(direction);
1151 if (!jdesc_.Initialize(desc_.Copy(),
1152 jdesc_.session_id(),
1153 jdesc_.session_version())) {
1154 return false;
1155 }
1156 EXPECT_TRUE(CompareSessionDescription(jdesc_, new_jdesc));
1157 return true;
1158 }
1159
1160 bool TestDeserializeRejected(bool audio_rejected, bool video_rejected) {
1161 std::string new_sdp = kSdpString;
1162 ReplaceRejected(audio_rejected, video_rejected, &new_sdp);
1163 JsepSessionDescription new_jdesc(JsepSessionDescription::kOffer);
1164 EXPECT_TRUE(SdpDeserialize(new_sdp, &new_jdesc));
1165
1166 audio_desc_ = static_cast<AudioContentDescription*>(
1167 audio_desc_->Copy());
1168 video_desc_ = static_cast<VideoContentDescription*>(
1169 video_desc_->Copy());
1170 desc_.RemoveContentByName(kAudioContentName);
1171 desc_.RemoveContentByName(kVideoContentName);
1172 desc_.AddContent(kAudioContentName, NS_JINGLE_RTP, audio_rejected,
1173 audio_desc_);
1174 desc_.AddContent(kVideoContentName, NS_JINGLE_RTP, video_rejected,
1175 video_desc_);
1176 SetIceUfragPwd(kAudioContentName,
1177 audio_rejected ? "" : kCandidateUfragVoice,
1178 audio_rejected ? "" : kCandidatePwdVoice);
1179 SetIceUfragPwd(kVideoContentName,
1180 video_rejected ? "" : kCandidateUfragVideo,
1181 video_rejected ? "" : kCandidatePwdVideo);
1182 JsepSessionDescription jdesc_no_candidates(kDummyString);
1183 if (!jdesc_no_candidates.Initialize(desc_.Copy(), jdesc_.session_id(),
1184 jdesc_.session_version())) {
1185 return false;
1186 }
1187 EXPECT_TRUE(CompareSessionDescription(jdesc_no_candidates, new_jdesc));
1188 return true;
1189 }
1190
1191 void TestDeserializeExtmap(bool session_level, bool media_level) {
1192 AddExtmap();
1193 JsepSessionDescription new_jdesc("dummy");
1194 ASSERT_TRUE(new_jdesc.Initialize(desc_.Copy(),
1195 jdesc_.session_id(),
1196 jdesc_.session_version()));
1197 JsepSessionDescription jdesc_with_extmap("dummy");
1198 std::string sdp_with_extmap = kSdpString;
1199 if (session_level) {
1200 InjectAfter(kSessionTime, kExtmapWithDirectionAndAttribute,
1201 &sdp_with_extmap);
1202 }
1203 if (media_level) {
1204 InjectAfter(kAttributeIcePwdVoice, kExtmapWithDirectionAndAttribute,
1205 &sdp_with_extmap);
1206 InjectAfter(kAttributeIcePwdVideo, kExtmapWithDirectionAndAttribute,
1207 &sdp_with_extmap);
1208 }
1209 // The extmap can't be present at the same time in both session level and
1210 // media level.
1211 if (session_level && media_level) {
1212 SdpParseError error;
1213 EXPECT_FALSE(webrtc::SdpDeserialize(sdp_with_extmap,
1214 &jdesc_with_extmap, &error));
1215 EXPECT_NE(std::string::npos, error.description.find("a=extmap"));
1216 } else {
1217 EXPECT_TRUE(SdpDeserialize(sdp_with_extmap, &jdesc_with_extmap));
1218 EXPECT_TRUE(CompareSessionDescription(jdesc_with_extmap, new_jdesc));
1219 }
1220 }
1221
1222 void VerifyCodecParameter(const cricket::CodecParameterMap& params,
1223 const std::string& name, int expected_value) {
1224 cricket::CodecParameterMap::const_iterator found = params.find(name);
1225 ASSERT_TRUE(found != params.end());
1226 EXPECT_EQ(found->second, rtc::ToString<int>(expected_value));
1227 }
1228
1229 void TestDeserializeCodecParams(const CodecParams& params,
1230 JsepSessionDescription* jdesc_output) {
1231 std::string sdp =
1232 "v=0\r\n"
1233 "o=- 18446744069414584320 18446462598732840960 IN IP4 127.0.0.1\r\n"
1234 "s=-\r\n"
1235 "t=0 0\r\n"
1236 // Include semantics for WebRTC Media Streams since it is supported by
1237 // this parser, and will be added to the SDP when serializing a session
1238 // description.
1239 "a=msid-semantic: WMS\r\n"
1240 // Pl type 111 preferred.
1241 "m=audio 9 RTP/SAVPF 111 104 103\r\n"
1242 // Pltype 111 listed before 103 and 104 in the map.
1243 "a=rtpmap:111 opus/48000/2\r\n"
1244 // Pltype 103 listed before 104.
1245 "a=rtpmap:103 ISAC/16000\r\n"
1246 "a=rtpmap:104 ISAC/32000\r\n"
1247 "a=fmtp:111 0-15,66,70\r\n"
1248 "a=fmtp:111 ";
1249 std::ostringstream os;
1250 os << "minptime=" << params.min_ptime << "; stereo=" << params.stereo
1251 << "; sprop-stereo=" << params.sprop_stereo
1252 << "; useinbandfec=" << params.useinband
1253 << "; maxaveragebitrate=" << params.maxaveragebitrate << "\r\n"
1254 << "a=ptime:" << params.ptime << "\r\n"
1255 << "a=maxptime:" << params.max_ptime << "\r\n";
1256 sdp += os.str();
1257
1258 os.clear();
1259 os.str("");
1260 // Pl type 100 preferred.
1261 os << "m=video 9 RTP/SAVPF 99 95\r\n"
1262 << "a=rtpmap:99 VP8/90000\r\n"
1263 << "a=rtpmap:95 RTX/90000\r\n"
1264 << "a=fmtp:95 apt=99;\r\n";
1265 sdp += os.str();
1266
1267 // Deserialize
1268 SdpParseError error;
1269 EXPECT_TRUE(webrtc::SdpDeserialize(sdp, jdesc_output, &error));
1270
1271 const ContentInfo* ac = GetFirstAudioContent(jdesc_output->description());
1272 ASSERT_TRUE(ac != NULL);
1273 const AudioContentDescription* acd =
1274 static_cast<const AudioContentDescription*>(ac->description);
1275 ASSERT_FALSE(acd->codecs().empty());
1276 cricket::AudioCodec opus = acd->codecs()[0];
1277 EXPECT_EQ("opus", opus.name);
1278 EXPECT_EQ(111, opus.id);
1279 VerifyCodecParameter(opus.params, "minptime", params.min_ptime);
1280 VerifyCodecParameter(opus.params, "stereo", params.stereo);
1281 VerifyCodecParameter(opus.params, "sprop-stereo", params.sprop_stereo);
1282 VerifyCodecParameter(opus.params, "useinbandfec", params.useinband);
1283 VerifyCodecParameter(opus.params, "maxaveragebitrate",
1284 params.maxaveragebitrate);
1285 for (size_t i = 0; i < acd->codecs().size(); ++i) {
1286 cricket::AudioCodec codec = acd->codecs()[i];
1287 VerifyCodecParameter(codec.params, "ptime", params.ptime);
1288 VerifyCodecParameter(codec.params, "maxptime", params.max_ptime);
1289 if (codec.name == "ISAC") {
1290 if (codec.clockrate == 16000) {
1291 EXPECT_EQ(32000, codec.bitrate);
1292 } else {
1293 EXPECT_EQ(56000, codec.bitrate);
1294 }
1295 }
1296 }
1297
1298 const ContentInfo* vc = GetFirstVideoContent(jdesc_output->description());
1299 ASSERT_TRUE(vc != NULL);
1300 const VideoContentDescription* vcd =
1301 static_cast<const VideoContentDescription*>(vc->description);
1302 ASSERT_FALSE(vcd->codecs().empty());
1303 cricket::VideoCodec vp8 = vcd->codecs()[0];
1304 EXPECT_EQ("VP8", vp8.name);
1305 EXPECT_EQ(99, vp8.id);
1306 cricket::VideoCodec rtx = vcd->codecs()[1];
1307 EXPECT_EQ("RTX", rtx.name);
1308 EXPECT_EQ(95, rtx.id);
1309 VerifyCodecParameter(rtx.params, "apt", vp8.id);
1310 }
1311
1312 void TestDeserializeRtcpFb(JsepSessionDescription* jdesc_output,
1313 bool use_wildcard) {
1314 std::string sdp_session_and_audio =
1315 "v=0\r\n"
1316 "o=- 18446744069414584320 18446462598732840960 IN IP4 127.0.0.1\r\n"
1317 "s=-\r\n"
1318 "t=0 0\r\n"
1319 // Include semantics for WebRTC Media Streams since it is supported by
1320 // this parser, and will be added to the SDP when serializing a session
1321 // description.
1322 "a=msid-semantic: WMS\r\n"
1323 "m=audio 9 RTP/SAVPF 111\r\n"
1324 "a=rtpmap:111 opus/48000/2\r\n";
1325 std::string sdp_video =
1326 "m=video 3457 RTP/SAVPF 101\r\n"
1327 "a=rtpmap:101 VP8/90000\r\n"
1328 "a=rtcp-fb:101 nack\r\n"
1329 "a=rtcp-fb:101 nack pli\r\n"
1330 "a=rtcp-fb:101 goog-remb\r\n";
1331 std::ostringstream os;
1332 os << sdp_session_and_audio;
1333 os << "a=rtcp-fb:" << (use_wildcard ? "*" : "111") << " nack\r\n";
1334 os << sdp_video;
1335 os << "a=rtcp-fb:" << (use_wildcard ? "*" : "101") << " ccm fir\r\n";
1336 std::string sdp = os.str();
1337 // Deserialize
1338 SdpParseError error;
1339 EXPECT_TRUE(webrtc::SdpDeserialize(sdp, jdesc_output, &error));
1340 const ContentInfo* ac = GetFirstAudioContent(jdesc_output->description());
1341 ASSERT_TRUE(ac != NULL);
1342 const AudioContentDescription* acd =
1343 static_cast<const AudioContentDescription*>(ac->description);
1344 ASSERT_FALSE(acd->codecs().empty());
1345 cricket::AudioCodec opus = acd->codecs()[0];
1346 EXPECT_EQ(111, opus.id);
1347 EXPECT_TRUE(opus.HasFeedbackParam(
1348 cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1349 cricket::kParamValueEmpty)));
1350
1351 const ContentInfo* vc = GetFirstVideoContent(jdesc_output->description());
1352 ASSERT_TRUE(vc != NULL);
1353 const VideoContentDescription* vcd =
1354 static_cast<const VideoContentDescription*>(vc->description);
1355 ASSERT_FALSE(vcd->codecs().empty());
1356 cricket::VideoCodec vp8 = vcd->codecs()[0];
1357 EXPECT_STREQ(webrtc::JsepSessionDescription::kDefaultVideoCodecName,
1358 vp8.name.c_str());
1359 EXPECT_EQ(101, vp8.id);
1360 EXPECT_TRUE(vp8.HasFeedbackParam(
1361 cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1362 cricket::kParamValueEmpty)));
1363 EXPECT_TRUE(vp8.HasFeedbackParam(
1364 cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1365 cricket::kRtcpFbNackParamPli)));
1366 EXPECT_TRUE(vp8.HasFeedbackParam(
1367 cricket::FeedbackParam(cricket::kRtcpFbParamRemb,
1368 cricket::kParamValueEmpty)));
1369 EXPECT_TRUE(vp8.HasFeedbackParam(
1370 cricket::FeedbackParam(cricket::kRtcpFbParamCcm,
1371 cricket::kRtcpFbCcmParamFir)));
1372 }
1373
1374 // Two SDP messages can mean the same thing but be different strings, e.g.
1375 // some of the lines can be serialized in different order.
1376 // However, a deserialized description can be compared field by field and has
1377 // no order. If deserializer has already been tested, serializing then
1378 // deserializing and comparing JsepSessionDescription will test
1379 // the serializer sufficiently.
1380 void TestSerialize(const JsepSessionDescription& jdesc) {
1381 std::string message = webrtc::SdpSerialize(jdesc);
1382 JsepSessionDescription jdesc_output_des(kDummyString);
1383 SdpParseError error;
1384 EXPECT_TRUE(webrtc::SdpDeserialize(message, &jdesc_output_des, &error));
1385 EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output_des));
1386 }
1387
1388 protected:
1389 SessionDescription desc_;
1390 AudioContentDescription* audio_desc_;
1391 VideoContentDescription* video_desc_;
1392 DataContentDescription* data_desc_;
1393 Candidates candidates_;
1394 rtc::scoped_ptr<IceCandidateInterface> jcandidate_;
1395 JsepSessionDescription jdesc_;
1396 };
1397
1398 void TestMismatch(const std::string& string1, const std::string& string2) {
1399 int position = 0;
1400 for (size_t i = 0; i < string1.length() && i < string2.length(); ++i) {
1401 if (string1.c_str()[i] != string2.c_str()[i]) {
1402 position = static_cast<int>(i);
1403 break;
1404 }
1405 }
1406 EXPECT_EQ(0, position) << "Strings mismatch at the " << position
1407 << " character\n"
1408 << " 1: " << string1.substr(position, 20) << "\n"
1409 << " 2: " << string2.substr(position, 20) << "\n";
1410 }
1411
1412 TEST_F(WebRtcSdpTest, SerializeSessionDescription) {
1413 // SessionDescription with desc and candidates.
1414 std::string message = webrtc::SdpSerialize(jdesc_);
1415 TestMismatch(std::string(kSdpFullString), message);
1416 }
1417
1418 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionEmpty) {
1419 JsepSessionDescription jdesc_empty(kDummyString);
1420 EXPECT_EQ("", webrtc::SdpSerialize(jdesc_empty));
1421 }
1422
1423 // This tests serialization of SDP with only IPv6 candidates and verifies that
1424 // IPv6 is used as default address in c line according to preference.
1425 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithIPv6Only) {
1426 // Only test 1 m line.
1427 desc_.RemoveContentByName("video_content_name");
1428 // Stun has a high preference than local host.
1429 cricket::Candidate candidate1(
1430 cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
1431 rtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
1432 cricket::STUN_PORT_TYPE, kCandidateGeneration, kCandidateFoundation1);
1433 cricket::Candidate candidate2(
1434 cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
1435 rtc::SocketAddress("::2", 1235), kCandidatePriority, "", "",
1436 cricket::LOCAL_PORT_TYPE, kCandidateGeneration, kCandidateFoundation1);
1437 JsepSessionDescription jdesc(kDummyString);
1438 ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
1439
1440 // Only add the candidates to audio m line.
1441 JsepIceCandidate jice1("audio_content_name", 0, candidate1);
1442 JsepIceCandidate jice2("audio_content_name", 0, candidate2);
1443 ASSERT_TRUE(jdesc.AddCandidate(&jice1));
1444 ASSERT_TRUE(jdesc.AddCandidate(&jice2));
1445 std::string message = webrtc::SdpSerialize(jdesc);
1446
1447 // Audio line should have a c line like this one.
1448 EXPECT_NE(message.find("c=IN IP6 ::1"), std::string::npos);
1449 // Shouldn't have a IP4 c line.
1450 EXPECT_EQ(message.find("c=IN IP4"), std::string::npos);
1451 }
1452
1453 // This tests serialization of SDP with both IPv4 and IPv6 candidates and
1454 // verifies that IPv4 is used as default address in c line even if the
1455 // preference of IPv4 is lower.
1456 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithBothIPFamilies) {
1457 // Only test 1 m line.
1458 desc_.RemoveContentByName("video_content_name");
1459 cricket::Candidate candidate_v4(
1460 cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
1461 rtc::SocketAddress("192.168.1.5", 1234), kCandidatePriority, "", "",
1462 cricket::STUN_PORT_TYPE, kCandidateGeneration, kCandidateFoundation1);
1463 cricket::Candidate candidate_v6(
1464 cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
1465 rtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
1466 cricket::LOCAL_PORT_TYPE, kCandidateGeneration, kCandidateFoundation1);
1467 JsepSessionDescription jdesc(kDummyString);
1468 ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
1469
1470 // Only add the candidates to audio m line.
1471 JsepIceCandidate jice_v4("audio_content_name", 0, candidate_v4);
1472 JsepIceCandidate jice_v6("audio_content_name", 0, candidate_v6);
1473 ASSERT_TRUE(jdesc.AddCandidate(&jice_v4));
1474 ASSERT_TRUE(jdesc.AddCandidate(&jice_v6));
1475 std::string message = webrtc::SdpSerialize(jdesc);
1476
1477 // Audio line should have a c line like this one.
1478 EXPECT_NE(message.find("c=IN IP4 192.168.1.5"), std::string::npos);
1479 // Shouldn't have a IP6 c line.
1480 EXPECT_EQ(message.find("c=IN IP6"), std::string::npos);
1481 }
1482
1483 // This tests serialization of SDP with both UDP and TCP candidates and
1484 // verifies that UDP is used as default address in c line even if the
1485 // preference of UDP is lower.
1486 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithBothProtocols) {
1487 // Only test 1 m line.
1488 desc_.RemoveContentByName("video_content_name");
1489 // Stun has a high preference than local host.
1490 cricket::Candidate candidate1(
1491 cricket::ICE_CANDIDATE_COMPONENT_RTP, "tcp",
1492 rtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
1493 cricket::STUN_PORT_TYPE, kCandidateGeneration, kCandidateFoundation1);
1494 cricket::Candidate candidate2(
1495 cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
1496 rtc::SocketAddress("fe80::1234:5678:abcd:ef12", 1235), kCandidatePriority,
1497 "", "", cricket::LOCAL_PORT_TYPE, kCandidateGeneration,
1498 kCandidateFoundation1);
1499 JsepSessionDescription jdesc(kDummyString);
1500 ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
1501
1502 // Only add the candidates to audio m line.
1503 JsepIceCandidate jice1("audio_content_name", 0, candidate1);
1504 JsepIceCandidate jice2("audio_content_name", 0, candidate2);
1505 ASSERT_TRUE(jdesc.AddCandidate(&jice1));
1506 ASSERT_TRUE(jdesc.AddCandidate(&jice2));
1507 std::string message = webrtc::SdpSerialize(jdesc);
1508
1509 // Audio line should have a c line like this one.
1510 EXPECT_NE(message.find("c=IN IP6 fe80::1234:5678:abcd:ef12"),
1511 std::string::npos);
1512 // Shouldn't have a IP4 c line.
1513 EXPECT_EQ(message.find("c=IN IP4"), std::string::npos);
1514 }
1515
1516 // This tests serialization of SDP with only TCP candidates and verifies that
1517 // null IPv4 is used as default address in c line.
1518 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithTCPOnly) {
1519 // Only test 1 m line.
1520 desc_.RemoveContentByName("video_content_name");
1521 // Stun has a high preference than local host.
1522 cricket::Candidate candidate1(
1523 cricket::ICE_CANDIDATE_COMPONENT_RTP, "tcp",
1524 rtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
1525 cricket::STUN_PORT_TYPE, kCandidateGeneration, kCandidateFoundation1);
1526 cricket::Candidate candidate2(
1527 cricket::ICE_CANDIDATE_COMPONENT_RTP, "tcp",
1528 rtc::SocketAddress("::2", 1235), kCandidatePriority, "", "",
1529 cricket::LOCAL_PORT_TYPE, kCandidateGeneration, kCandidateFoundation1);
1530 JsepSessionDescription jdesc(kDummyString);
1531 ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
1532
1533 // Only add the candidates to audio m line.
1534 JsepIceCandidate jice1("audio_content_name", 0, candidate1);
1535 JsepIceCandidate jice2("audio_content_name", 0, candidate2);
1536 ASSERT_TRUE(jdesc.AddCandidate(&jice1));
1537 ASSERT_TRUE(jdesc.AddCandidate(&jice2));
1538 std::string message = webrtc::SdpSerialize(jdesc);
1539
1540 // Audio line should have a c line like this one when no any default exists.
1541 EXPECT_NE(message.find("c=IN IP4 0.0.0.0"), std::string::npos);
1542 }
1543
1544 // This tests serialization of SDP with a=crypto and a=fingerprint, as would be
1545 // the case in a DTLS offer.
1546 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithFingerprint) {
1547 AddFingerprint();
1548 JsepSessionDescription jdesc_with_fingerprint(kDummyString);
1549 ASSERT_TRUE(jdesc_with_fingerprint.Initialize(desc_.Copy(),
1550 kSessionId, kSessionVersion));
1551 std::string message = webrtc::SdpSerialize(jdesc_with_fingerprint);
1552
1553 std::string sdp_with_fingerprint = kSdpString;
1554 InjectAfter(kAttributeIcePwdVoice,
1555 kFingerprint, &sdp_with_fingerprint);
1556 InjectAfter(kAttributeIcePwdVideo,
1557 kFingerprint, &sdp_with_fingerprint);
1558
1559 EXPECT_EQ(sdp_with_fingerprint, message);
1560 }
1561
1562 // This tests serialization of SDP with a=fingerprint with no a=crypto, as would
1563 // be the case in a DTLS answer.
1564 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithFingerprintNoCryptos) {
1565 AddFingerprint();
1566 RemoveCryptos();
1567 JsepSessionDescription jdesc_with_fingerprint(kDummyString);
1568 ASSERT_TRUE(jdesc_with_fingerprint.Initialize(desc_.Copy(),
1569 kSessionId, kSessionVersion));
1570 std::string message = webrtc::SdpSerialize(jdesc_with_fingerprint);
1571
1572 std::string sdp_with_fingerprint = kSdpString;
1573 Replace(kAttributeCryptoVoice, "", &sdp_with_fingerprint);
1574 Replace(kAttributeCryptoVideo, "", &sdp_with_fingerprint);
1575 InjectAfter(kAttributeIcePwdVoice,
1576 kFingerprint, &sdp_with_fingerprint);
1577 InjectAfter(kAttributeIcePwdVideo,
1578 kFingerprint, &sdp_with_fingerprint);
1579
1580 EXPECT_EQ(sdp_with_fingerprint, message);
1581 }
1582
1583 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithoutCandidates) {
1584 // JsepSessionDescription with desc but without candidates.
1585 JsepSessionDescription jdesc_no_candidates(kDummyString);
1586 ASSERT_TRUE(jdesc_no_candidates.Initialize(desc_.Copy(), kSessionId,
1587 kSessionVersion));
1588 std::string message = webrtc::SdpSerialize(jdesc_no_candidates);
1589 EXPECT_EQ(std::string(kSdpString), message);
1590 }
1591
1592 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithBundle) {
1593 ContentGroup group(cricket::GROUP_TYPE_BUNDLE);
1594 group.AddContentName(kAudioContentName);
1595 group.AddContentName(kVideoContentName);
1596 desc_.AddGroup(group);
1597 ASSERT_TRUE(jdesc_.Initialize(desc_.Copy(),
1598 jdesc_.session_id(),
1599 jdesc_.session_version()));
1600 std::string message = webrtc::SdpSerialize(jdesc_);
1601 std::string sdp_with_bundle = kSdpFullString;
1602 InjectAfter(kSessionTime,
1603 "a=group:BUNDLE audio_content_name video_content_name\r\n",
1604 &sdp_with_bundle);
1605 EXPECT_EQ(sdp_with_bundle, message);
1606 }
1607
1608 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithBandwidth) {
1609 VideoContentDescription* vcd = static_cast<VideoContentDescription*>(
1610 GetFirstVideoContent(&desc_)->description);
1611 vcd->set_bandwidth(100 * 1000);
1612 AudioContentDescription* acd = static_cast<AudioContentDescription*>(
1613 GetFirstAudioContent(&desc_)->description);
1614 acd->set_bandwidth(50 * 1000);
1615 ASSERT_TRUE(jdesc_.Initialize(desc_.Copy(),
1616 jdesc_.session_id(),
1617 jdesc_.session_version()));
1618 std::string message = webrtc::SdpSerialize(jdesc_);
1619 std::string sdp_with_bandwidth = kSdpFullString;
1620 InjectAfter("c=IN IP4 74.125.224.39\r\n",
1621 "b=AS:100\r\n",
1622 &sdp_with_bandwidth);
1623 InjectAfter("c=IN IP4 74.125.127.126\r\n",
1624 "b=AS:50\r\n",
1625 &sdp_with_bandwidth);
1626 EXPECT_EQ(sdp_with_bandwidth, message);
1627 }
1628
1629 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithIceOptions) {
1630 std::vector<std::string> transport_options;
1631 transport_options.push_back(kIceOption1);
1632 transport_options.push_back(kIceOption3);
1633 AddIceOptions(kAudioContentName, transport_options);
1634 transport_options.clear();
1635 transport_options.push_back(kIceOption2);
1636 transport_options.push_back(kIceOption3);
1637 AddIceOptions(kVideoContentName, transport_options);
1638 ASSERT_TRUE(jdesc_.Initialize(desc_.Copy(),
1639 jdesc_.session_id(),
1640 jdesc_.session_version()));
1641 std::string message = webrtc::SdpSerialize(jdesc_);
1642 std::string sdp_with_ice_options = kSdpFullString;
1643 InjectAfter(kAttributeIcePwdVoice,
1644 "a=ice-options:iceoption1 iceoption3\r\n",
1645 &sdp_with_ice_options);
1646 InjectAfter(kAttributeIcePwdVideo,
1647 "a=ice-options:iceoption2 iceoption3\r\n",
1648 &sdp_with_ice_options);
1649 EXPECT_EQ(sdp_with_ice_options, message);
1650 }
1651
1652 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithRecvOnlyContent) {
1653 EXPECT_TRUE(TestSerializeDirection(cricket::MD_RECVONLY));
1654 }
1655
1656 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithSendOnlyContent) {
1657 EXPECT_TRUE(TestSerializeDirection(cricket::MD_SENDONLY));
1658 }
1659
1660 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithInactiveContent) {
1661 EXPECT_TRUE(TestSerializeDirection(cricket::MD_INACTIVE));
1662 }
1663
1664 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithAudioRejected) {
1665 EXPECT_TRUE(TestSerializeRejected(true, false));
1666 }
1667
1668 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithVideoRejected) {
1669 EXPECT_TRUE(TestSerializeRejected(false, true));
1670 }
1671
1672 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithAudioVideoRejected) {
1673 EXPECT_TRUE(TestSerializeRejected(true, true));
1674 }
1675
1676 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithRtpDataChannel) {
1677 AddRtpDataChannel();
1678 JsepSessionDescription jsep_desc(kDummyString);
1679
1680 ASSERT_TRUE(jsep_desc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
1681 std::string message = webrtc::SdpSerialize(jsep_desc);
1682
1683 std::string expected_sdp = kSdpString;
1684 expected_sdp.append(kSdpRtpDataChannelString);
1685 EXPECT_EQ(expected_sdp, message);
1686 }
1687
1688 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithSctpDataChannel) {
1689 AddSctpDataChannel();
1690 JsepSessionDescription jsep_desc(kDummyString);
1691
1692 ASSERT_TRUE(jsep_desc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
1693 std::string message = webrtc::SdpSerialize(jsep_desc);
1694
1695 std::string expected_sdp = kSdpString;
1696 expected_sdp.append(kSdpSctpDataChannelString);
1697 EXPECT_EQ(message, expected_sdp);
1698 }
1699
1700 TEST_F(WebRtcSdpTest, SerializeWithSctpDataChannelAndNewPort) {
1701 AddSctpDataChannel();
1702 JsepSessionDescription jsep_desc(kDummyString);
1703
1704 ASSERT_TRUE(jsep_desc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
1705 DataContentDescription* dcdesc = static_cast<DataContentDescription*>(
1706 jsep_desc.description()->GetContentDescriptionByName(kDataContentName));
1707
1708 const int kNewPort = 1234;
1709 cricket::DataCodec codec(
1710 cricket::kGoogleSctpDataCodecId, cricket::kGoogleSctpDataCodecName, 0);
1711 codec.SetParam(cricket::kCodecParamPort, kNewPort);
1712 dcdesc->AddOrReplaceCodec(codec);
1713
1714 std::string message = webrtc::SdpSerialize(jsep_desc);
1715
1716 std::string expected_sdp = kSdpString;
1717 expected_sdp.append(kSdpSctpDataChannelString);
1718
1719 char default_portstr[16];
1720 char new_portstr[16];
1721 rtc::sprintfn(default_portstr, sizeof(default_portstr), "%d",
1722 kDefaultSctpPort);
1723 rtc::sprintfn(new_portstr, sizeof(new_portstr), "%d", kNewPort);
1724 rtc::replace_substrs(default_portstr, strlen(default_portstr),
1725 new_portstr, strlen(new_portstr),
1726 &expected_sdp);
1727
1728 EXPECT_EQ(expected_sdp, message);
1729 }
1730
1731 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithDataChannelAndBandwidth) {
1732 AddRtpDataChannel();
1733 data_desc_->set_bandwidth(100*1000);
1734 JsepSessionDescription jsep_desc(kDummyString);
1735
1736 ASSERT_TRUE(jsep_desc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
1737 std::string message = webrtc::SdpSerialize(jsep_desc);
1738
1739 std::string expected_sdp = kSdpString;
1740 expected_sdp.append(kSdpRtpDataChannelString);
1741 // Serializing data content shouldn't ignore bandwidth settings.
1742 InjectAfter("m=application 9 RTP/SAVPF 101\r\nc=IN IP4 0.0.0.0\r\n",
1743 "b=AS:100\r\n",
1744 &expected_sdp);
1745 EXPECT_EQ(expected_sdp, message);
1746 }
1747
1748 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithExtmap) {
1749 AddExtmap();
1750 JsepSessionDescription desc_with_extmap("dummy");
1751 ASSERT_TRUE(desc_with_extmap.Initialize(desc_.Copy(),
1752 kSessionId, kSessionVersion));
1753 std::string message = webrtc::SdpSerialize(desc_with_extmap);
1754
1755 std::string sdp_with_extmap = kSdpString;
1756 InjectAfter("a=mid:audio_content_name\r\n",
1757 kExtmap, &sdp_with_extmap);
1758 InjectAfter("a=mid:video_content_name\r\n",
1759 kExtmap, &sdp_with_extmap);
1760
1761 EXPECT_EQ(sdp_with_extmap, message);
1762 }
1763
1764 TEST_F(WebRtcSdpTest, SerializeCandidates) {
1765 std::string message = webrtc::SdpSerializeCandidate(*jcandidate_);
1766 EXPECT_EQ(std::string(kRawCandidate), message);
1767
1768 Candidate candidate_with_ufrag(candidates_.front());
1769 candidate_with_ufrag.set_username("ABC");
1770 jcandidate_.reset(new JsepIceCandidate(std::string("audio_content_name"), 0,
1771 candidate_with_ufrag));
1772 message = webrtc::SdpSerializeCandidate(*jcandidate_);
1773 EXPECT_EQ(std::string(kRawCandidate) + " ufrag ABC", message);
1774 }
1775
1776 // TODO(mallinath) : Enable this test once WebRTCSdp capable of parsing
1777 // RFC 6544.
1778 TEST_F(WebRtcSdpTest, SerializeTcpCandidates) {
1779 Candidate candidate(ICE_CANDIDATE_COMPONENT_RTP, "tcp",
1780 rtc::SocketAddress("192.168.1.5", 9), kCandidatePriority,
1781 "", "", LOCAL_PORT_TYPE, kCandidateGeneration,
1782 kCandidateFoundation1);
1783 candidate.set_tcptype(cricket::TCPTYPE_ACTIVE_STR);
1784 rtc::scoped_ptr<IceCandidateInterface> jcandidate(
1785 new JsepIceCandidate(std::string("audio_content_name"), 0, candidate));
1786
1787 std::string message = webrtc::SdpSerializeCandidate(*jcandidate);
1788 EXPECT_EQ(std::string(kSdpTcpActiveCandidate), message);
1789 }
1790
1791 TEST_F(WebRtcSdpTest, DeserializeSessionDescription) {
1792 JsepSessionDescription jdesc(kDummyString);
1793 // Deserialize
1794 EXPECT_TRUE(SdpDeserialize(kSdpFullString, &jdesc));
1795 // Verify
1796 EXPECT_TRUE(CompareSessionDescription(jdesc_, jdesc));
1797 }
1798
1799 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithoutMline) {
1800 JsepSessionDescription jdesc(kDummyString);
1801 const char kSdpWithoutMline[] =
1802 "v=0\r\n"
1803 "o=- 18446744069414584320 18446462598732840960 IN IP4 127.0.0.1\r\n"
1804 "s=-\r\n"
1805 "t=0 0\r\n"
1806 "a=msid-semantic: WMS local_stream_1 local_stream_2\r\n";
1807 // Deserialize
1808 EXPECT_TRUE(SdpDeserialize(kSdpWithoutMline, &jdesc));
1809 EXPECT_EQ(0u, jdesc.description()->contents().size());
1810 }
1811
1812 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithoutCarriageReturn) {
1813 JsepSessionDescription jdesc(kDummyString);
1814 std::string sdp_without_carriage_return = kSdpFullString;
1815 Replace("\r\n", "\n", &sdp_without_carriage_return);
1816 // Deserialize
1817 EXPECT_TRUE(SdpDeserialize(sdp_without_carriage_return, &jdesc));
1818 // Verify
1819 EXPECT_TRUE(CompareSessionDescription(jdesc_, jdesc));
1820 }
1821
1822 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithoutCandidates) {
1823 // SessionDescription with desc but without candidates.
1824 JsepSessionDescription jdesc_no_candidates(kDummyString);
1825 ASSERT_TRUE(jdesc_no_candidates.Initialize(desc_.Copy(),
1826 kSessionId, kSessionVersion));
1827 JsepSessionDescription new_jdesc(kDummyString);
1828 EXPECT_TRUE(SdpDeserialize(kSdpString, &new_jdesc));
1829 EXPECT_TRUE(CompareSessionDescription(jdesc_no_candidates, new_jdesc));
1830 }
1831
1832 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithoutRtpmap) {
1833 static const char kSdpNoRtpmapString[] =
1834 "v=0\r\n"
1835 "o=- 11 22 IN IP4 127.0.0.1\r\n"
1836 "s=-\r\n"
1837 "t=0 0\r\n"
1838 "m=audio 49232 RTP/AVP 0 18 103\r\n"
1839 // Codec that doesn't appear in the m= line will be ignored.
1840 "a=rtpmap:104 ISAC/32000\r\n"
1841 // The rtpmap line for static payload codec is optional.
1842 "a=rtpmap:18 G729/16000\r\n"
1843 "a=rtpmap:103 ISAC/16000\r\n";
1844
1845 JsepSessionDescription jdesc(kDummyString);
1846 EXPECT_TRUE(SdpDeserialize(kSdpNoRtpmapString, &jdesc));
1847 cricket::AudioContentDescription* audio =
1848 static_cast<AudioContentDescription*>(
1849 jdesc.description()->GetContentDescriptionByName(cricket::CN_AUDIO));
1850 AudioCodecs ref_codecs;
1851 // The codecs in the AudioContentDescription will be sorted by preference.
1852 ref_codecs.push_back(AudioCodec(0, "PCMU", 8000, 0, 1, 3));
1853 ref_codecs.push_back(AudioCodec(18, "G729", 16000, 0, 1, 2));
1854 ref_codecs.push_back(AudioCodec(103, "ISAC", 16000, 32000, 1, 1));
1855 EXPECT_EQ(ref_codecs, audio->codecs());
1856 }
1857
1858 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithoutRtpmapButWithFmtp) {
1859 static const char kSdpNoRtpmapString[] =
1860 "v=0\r\n"
1861 "o=- 11 22 IN IP4 127.0.0.1\r\n"
1862 "s=-\r\n"
1863 "t=0 0\r\n"
1864 "m=audio 49232 RTP/AVP 18 103\r\n"
1865 "a=fmtp:18 annexb=yes\r\n"
1866 "a=rtpmap:103 ISAC/16000\r\n";
1867
1868 JsepSessionDescription jdesc(kDummyString);
1869 EXPECT_TRUE(SdpDeserialize(kSdpNoRtpmapString, &jdesc));
1870 cricket::AudioContentDescription* audio =
1871 static_cast<AudioContentDescription*>(
1872 jdesc.description()->GetContentDescriptionByName(cricket::CN_AUDIO));
1873
1874 cricket::AudioCodec g729 = audio->codecs()[0];
1875 EXPECT_EQ("G729", g729.name);
1876 EXPECT_EQ(8000, g729.clockrate);
1877 EXPECT_EQ(18, g729.id);
1878 cricket::CodecParameterMap::iterator found =
1879 g729.params.find("annexb");
1880 ASSERT_TRUE(found != g729.params.end());
1881 EXPECT_EQ(found->second, "yes");
1882
1883 cricket::AudioCodec isac = audio->codecs()[1];
1884 EXPECT_EQ("ISAC", isac.name);
1885 EXPECT_EQ(103, isac.id);
1886 EXPECT_EQ(16000, isac.clockrate);
1887 }
1888
1889 // Ensure that we can deserialize SDP with a=fingerprint properly.
1890 TEST_F(WebRtcSdpTest, DeserializeJsepSessionDescriptionWithFingerprint) {
1891 // Add a DTLS a=fingerprint attribute to our session description.
1892 AddFingerprint();
1893 JsepSessionDescription new_jdesc(kDummyString);
1894 ASSERT_TRUE(new_jdesc.Initialize(desc_.Copy(),
1895 jdesc_.session_id(),
1896 jdesc_.session_version()));
1897
1898 JsepSessionDescription jdesc_with_fingerprint(kDummyString);
1899 std::string sdp_with_fingerprint = kSdpString;
1900 InjectAfter(kAttributeIcePwdVoice, kFingerprint, &sdp_with_fingerprint);
1901 InjectAfter(kAttributeIcePwdVideo, kFingerprint, &sdp_with_fingerprint);
1902 EXPECT_TRUE(SdpDeserialize(sdp_with_fingerprint, &jdesc_with_fingerprint));
1903 EXPECT_TRUE(CompareSessionDescription(jdesc_with_fingerprint, new_jdesc));
1904 }
1905
1906 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithBundle) {
1907 JsepSessionDescription jdesc_with_bundle(kDummyString);
1908 std::string sdp_with_bundle = kSdpFullString;
1909 InjectAfter(kSessionTime,
1910 "a=group:BUNDLE audio_content_name video_content_name\r\n",
1911 &sdp_with_bundle);
1912 EXPECT_TRUE(SdpDeserialize(sdp_with_bundle, &jdesc_with_bundle));
1913 ContentGroup group(cricket::GROUP_TYPE_BUNDLE);
1914 group.AddContentName(kAudioContentName);
1915 group.AddContentName(kVideoContentName);
1916 desc_.AddGroup(group);
1917 ASSERT_TRUE(jdesc_.Initialize(desc_.Copy(),
1918 jdesc_.session_id(),
1919 jdesc_.session_version()));
1920 EXPECT_TRUE(CompareSessionDescription(jdesc_, jdesc_with_bundle));
1921 }
1922
1923 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithBandwidth) {
1924 JsepSessionDescription jdesc_with_bandwidth(kDummyString);
1925 std::string sdp_with_bandwidth = kSdpFullString;
1926 InjectAfter("a=mid:video_content_name\r\na=sendrecv\r\n",
1927 "b=AS:100\r\n",
1928 &sdp_with_bandwidth);
1929 InjectAfter("a=mid:audio_content_name\r\na=sendrecv\r\n",
1930 "b=AS:50\r\n",
1931 &sdp_with_bandwidth);
1932 EXPECT_TRUE(
1933 SdpDeserialize(sdp_with_bandwidth, &jdesc_with_bandwidth));
1934 VideoContentDescription* vcd = static_cast<VideoContentDescription*>(
1935 GetFirstVideoContent(&desc_)->description);
1936 vcd->set_bandwidth(100 * 1000);
1937 AudioContentDescription* acd = static_cast<AudioContentDescription*>(
1938 GetFirstAudioContent(&desc_)->description);
1939 acd->set_bandwidth(50 * 1000);
1940 ASSERT_TRUE(jdesc_.Initialize(desc_.Copy(),
1941 jdesc_.session_id(),
1942 jdesc_.session_version()));
1943 EXPECT_TRUE(CompareSessionDescription(jdesc_, jdesc_with_bandwidth));
1944 }
1945
1946 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithIceOptions) {
1947 JsepSessionDescription jdesc_with_ice_options(kDummyString);
1948 std::string sdp_with_ice_options = kSdpFullString;
1949 InjectAfter(kSessionTime,
1950 "a=ice-options:iceoption3\r\n",
1951 &sdp_with_ice_options);
1952 InjectAfter(kAttributeIcePwdVoice,
1953 "a=ice-options:iceoption1\r\n",
1954 &sdp_with_ice_options);
1955 InjectAfter(kAttributeIcePwdVideo,
1956 "a=ice-options:iceoption2\r\n",
1957 &sdp_with_ice_options);
1958 EXPECT_TRUE(SdpDeserialize(sdp_with_ice_options, &jdesc_with_ice_options));
1959 std::vector<std::string> transport_options;
1960 transport_options.push_back(kIceOption3);
1961 transport_options.push_back(kIceOption1);
1962 AddIceOptions(kAudioContentName, transport_options);
1963 transport_options.clear();
1964 transport_options.push_back(kIceOption3);
1965 transport_options.push_back(kIceOption2);
1966 AddIceOptions(kVideoContentName, transport_options);
1967 ASSERT_TRUE(jdesc_.Initialize(desc_.Copy(),
1968 jdesc_.session_id(),
1969 jdesc_.session_version()));
1970 EXPECT_TRUE(CompareSessionDescription(jdesc_, jdesc_with_ice_options));
1971 }
1972
1973 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithUfragPwd) {
1974 // Remove the original ice-ufrag and ice-pwd
1975 JsepSessionDescription jdesc_with_ufrag_pwd(kDummyString);
1976 std::string sdp_with_ufrag_pwd = kSdpFullString;
1977 EXPECT_TRUE(RemoveCandidateUfragPwd(&sdp_with_ufrag_pwd));
1978 // Add session level ufrag and pwd
1979 InjectAfter(kSessionTime,
1980 "a=ice-pwd:session+level+icepwd\r\n"
1981 "a=ice-ufrag:session+level+iceufrag\r\n",
1982 &sdp_with_ufrag_pwd);
1983 // Add media level ufrag and pwd for audio
1984 InjectAfter("a=mid:audio_content_name\r\n",
1985 "a=ice-pwd:media+level+icepwd\r\na=ice-ufrag:media+level+iceufrag\r\n",
1986 &sdp_with_ufrag_pwd);
1987 // Update the candidate ufrag and pwd to the expected ones.
1988 EXPECT_TRUE(UpdateCandidateUfragPwd(&jdesc_, 0,
1989 "media+level+iceufrag", "media+level+icepwd"));
1990 EXPECT_TRUE(UpdateCandidateUfragPwd(&jdesc_, 1,
1991 "session+level+iceufrag", "session+level+icepwd"));
1992 EXPECT_TRUE(SdpDeserialize(sdp_with_ufrag_pwd, &jdesc_with_ufrag_pwd));
1993 EXPECT_TRUE(CompareSessionDescription(jdesc_, jdesc_with_ufrag_pwd));
1994 }
1995
1996 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithRecvOnlyContent) {
1997 EXPECT_TRUE(TestDeserializeDirection(cricket::MD_RECVONLY));
1998 }
1999
2000 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithSendOnlyContent) {
2001 EXPECT_TRUE(TestDeserializeDirection(cricket::MD_SENDONLY));
2002 }
2003
2004 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithInactiveContent) {
2005 EXPECT_TRUE(TestDeserializeDirection(cricket::MD_INACTIVE));
2006 }
2007
2008 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithRejectedAudio) {
2009 EXPECT_TRUE(TestDeserializeRejected(true, false));
2010 }
2011
2012 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithRejectedVideo) {
2013 EXPECT_TRUE(TestDeserializeRejected(false, true));
2014 }
2015
2016 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithRejectedAudioVideo) {
2017 EXPECT_TRUE(TestDeserializeRejected(true, true));
2018 }
2019
2020 // Tests that we can still handle the sdp uses mslabel and label instead of
2021 // msid for backward compatibility.
2022 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithoutMsid) {
2023 jdesc_.description()->set_msid_supported(false);
2024 JsepSessionDescription jdesc(kDummyString);
2025 std::string sdp_without_msid = kSdpFullString;
2026 Replace("msid", "xmsid", &sdp_without_msid);
2027 // Deserialize
2028 EXPECT_TRUE(SdpDeserialize(sdp_without_msid, &jdesc));
2029 // Verify
2030 EXPECT_TRUE(CompareSessionDescription(jdesc_, jdesc));
2031 }
2032
2033 TEST_F(WebRtcSdpTest, DeserializeCandidate) {
2034 JsepIceCandidate jcandidate(kDummyMid, kDummyIndex);
2035
2036 std::string sdp = kSdpOneCandidate;
2037 EXPECT_TRUE(SdpDeserializeCandidate(sdp, &jcandidate));
2038 EXPECT_EQ(kDummyMid, jcandidate.sdp_mid());
2039 EXPECT_EQ(kDummyIndex, jcandidate.sdp_mline_index());
2040 EXPECT_TRUE(jcandidate.candidate().IsEquivalent(jcandidate_->candidate()));
2041
2042 // Candidate line without generation extension.
2043 sdp = kSdpOneCandidate;
2044 Replace(" generation 2", "", &sdp);
2045 EXPECT_TRUE(SdpDeserializeCandidate(sdp, &jcandidate));
2046 EXPECT_EQ(kDummyMid, jcandidate.sdp_mid());
2047 EXPECT_EQ(kDummyIndex, jcandidate.sdp_mline_index());
2048 Candidate expected = jcandidate_->candidate();
2049 expected.set_generation(0);
2050 EXPECT_TRUE(jcandidate.candidate().IsEquivalent(expected));
2051
2052 sdp = kSdpTcpActiveCandidate;
2053 EXPECT_TRUE(SdpDeserializeCandidate(sdp, &jcandidate));
2054 // Make a cricket::Candidate equivalent to kSdpTcpCandidate string.
2055 Candidate candidate(ICE_CANDIDATE_COMPONENT_RTP, "tcp",
2056 rtc::SocketAddress("192.168.1.5", 9), kCandidatePriority,
2057 "", "", LOCAL_PORT_TYPE, kCandidateGeneration,
2058 kCandidateFoundation1);
2059 rtc::scoped_ptr<IceCandidateInterface> jcandidate_template(
2060 new JsepIceCandidate(std::string("audio_content_name"), 0, candidate));
2061 EXPECT_TRUE(jcandidate.candidate().IsEquivalent(
2062 jcandidate_template->candidate()));
2063 sdp = kSdpTcpPassiveCandidate;
2064 EXPECT_TRUE(SdpDeserializeCandidate(sdp, &jcandidate));
2065 sdp = kSdpTcpSOCandidate;
2066 EXPECT_TRUE(SdpDeserializeCandidate(sdp, &jcandidate));
2067 }
2068
2069 // This test verifies the deserialization of candidate-attribute
2070 // as per RFC 5245. Candiate-attribute will be of the format
2071 // candidate:<blah>. This format will be used when candidates
2072 // are trickled.
2073 TEST_F(WebRtcSdpTest, DeserializeRawCandidateAttribute) {
2074 JsepIceCandidate jcandidate(kDummyMid, kDummyIndex);
2075
2076 std::string candidate_attribute = kRawCandidate;
2077 EXPECT_TRUE(SdpDeserializeCandidate(candidate_attribute, &jcandidate));
2078 EXPECT_EQ(kDummyMid, jcandidate.sdp_mid());
2079 EXPECT_EQ(kDummyIndex, jcandidate.sdp_mline_index());
2080 EXPECT_TRUE(jcandidate.candidate().IsEquivalent(jcandidate_->candidate()));
2081 EXPECT_EQ(2u, jcandidate.candidate().generation());
2082
2083 // Candidate line without generation extension.
2084 candidate_attribute = kRawCandidate;
2085 Replace(" generation 2", "", &candidate_attribute);
2086 EXPECT_TRUE(SdpDeserializeCandidate(candidate_attribute, &jcandidate));
2087 EXPECT_EQ(kDummyMid, jcandidate.sdp_mid());
2088 EXPECT_EQ(kDummyIndex, jcandidate.sdp_mline_index());
2089 Candidate expected = jcandidate_->candidate();
2090 expected.set_generation(0);
2091 EXPECT_TRUE(jcandidate.candidate().IsEquivalent(expected));
2092
2093 // Candidate line without candidate:
2094 candidate_attribute = kRawCandidate;
2095 Replace("candidate:", "", &candidate_attribute);
2096 EXPECT_FALSE(SdpDeserializeCandidate(candidate_attribute, &jcandidate));
2097
2098 // Candidate line with IPV6 address.
2099 EXPECT_TRUE(SdpDeserializeCandidate(kRawIPV6Candidate, &jcandidate));
2100 }
2101
2102 // This test verifies that the deserialization of an invalid candidate string
2103 // fails.
2104 TEST_F(WebRtcSdpTest, DeserializeInvalidCandidiate) {
2105 JsepIceCandidate jcandidate(kDummyMid, kDummyIndex);
2106
2107 std::string candidate_attribute = kRawCandidate;
2108 candidate_attribute.replace(0, 1, "x");
2109 EXPECT_FALSE(SdpDeserializeCandidate(candidate_attribute, &jcandidate));
2110
2111 candidate_attribute = kSdpOneCandidate;
2112 candidate_attribute.replace(0, 1, "x");
2113 EXPECT_FALSE(SdpDeserializeCandidate(candidate_attribute, &jcandidate));
2114
2115 candidate_attribute = kRawCandidate;
2116 candidate_attribute.append("\r\n");
2117 candidate_attribute.append(kRawCandidate);
2118 EXPECT_FALSE(SdpDeserializeCandidate(candidate_attribute, &jcandidate));
2119
2120 EXPECT_FALSE(SdpDeserializeCandidate(kSdpTcpInvalidCandidate, &jcandidate));
2121 }
2122
2123 TEST_F(WebRtcSdpTest, DeserializeSdpWithRtpDataChannels) {
2124 AddRtpDataChannel();
2125 JsepSessionDescription jdesc(kDummyString);
2126 ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
2127
2128 std::string sdp_with_data = kSdpString;
2129 sdp_with_data.append(kSdpRtpDataChannelString);
2130 JsepSessionDescription jdesc_output(kDummyString);
2131
2132 // Deserialize
2133 EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
2134 // Verify
2135 EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
2136 }
2137
2138 TEST_F(WebRtcSdpTest, DeserializeSdpWithSctpDataChannels) {
2139 AddSctpDataChannel();
2140 JsepSessionDescription jdesc(kDummyString);
2141 ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
2142
2143 std::string sdp_with_data = kSdpString;
2144 sdp_with_data.append(kSdpSctpDataChannelString);
2145 JsepSessionDescription jdesc_output(kDummyString);
2146
2147 // Verify with DTLS/SCTP (already in kSdpSctpDataChannelString).
2148 EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
2149 EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
2150
2151 // Verify with UDP/DTLS/SCTP.
2152 sdp_with_data.replace(sdp_with_data.find(kDtlsSctp),
2153 strlen(kDtlsSctp), kUdpDtlsSctp);
2154 EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
2155 EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
2156
2157 // Verify with TCP/DTLS/SCTP.
2158 sdp_with_data.replace(sdp_with_data.find(kUdpDtlsSctp),
2159 strlen(kUdpDtlsSctp), kTcpDtlsSctp);
2160 EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
2161 EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
2162 }
2163
2164 TEST_F(WebRtcSdpTest, DeserializeSdpWithSctpDataChannelsWithSctpPort) {
2165 AddSctpDataChannel();
2166 JsepSessionDescription jdesc(kDummyString);
2167 ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
2168
2169 std::string sdp_with_data = kSdpString;
2170 sdp_with_data.append(kSdpSctpDataChannelStringWithSctpPort);
2171 JsepSessionDescription jdesc_output(kDummyString);
2172
2173 // Verify with DTLS/SCTP (already in kSdpSctpDataChannelStringWithSctpPort).
2174 EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
2175 EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
2176
2177 // Verify with UDP/DTLS/SCTP.
2178 sdp_with_data.replace(sdp_with_data.find(kDtlsSctp),
2179 strlen(kDtlsSctp), kUdpDtlsSctp);
2180 EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
2181 EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
2182
2183 // Verify with TCP/DTLS/SCTP.
2184 sdp_with_data.replace(sdp_with_data.find(kUdpDtlsSctp),
2185 strlen(kUdpDtlsSctp), kTcpDtlsSctp);
2186 EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
2187 EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
2188 }
2189
2190 TEST_F(WebRtcSdpTest, DeserializeSdpWithSctpDataChannelsWithSctpColonPort) {
2191 AddSctpDataChannel();
2192 JsepSessionDescription jdesc(kDummyString);
2193 ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
2194
2195 std::string sdp_with_data = kSdpString;
2196 sdp_with_data.append(kSdpSctpDataChannelStringWithSctpColonPort);
2197 JsepSessionDescription jdesc_output(kDummyString);
2198
2199 // Verify with DTLS/SCTP.
2200 EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
2201 EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
2202
2203 // Verify with UDP/DTLS/SCTP.
2204 sdp_with_data.replace(sdp_with_data.find(kDtlsSctp),
2205 strlen(kDtlsSctp), kUdpDtlsSctp);
2206 EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
2207 EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
2208
2209 // Verify with TCP/DTLS/SCTP.
2210 sdp_with_data.replace(sdp_with_data.find(kUdpDtlsSctp),
2211 strlen(kUdpDtlsSctp), kTcpDtlsSctp);
2212 EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
2213 EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
2214 }
2215
2216 // Test to check the behaviour if sctp-port is specified
2217 // on the m= line and in a=sctp-port.
2218 TEST_F(WebRtcSdpTest, DeserializeSdpWithMultiSctpPort) {
2219 AddSctpDataChannel();
2220 JsepSessionDescription jdesc(kDummyString);
2221 ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
2222
2223 std::string sdp_with_data = kSdpString;
2224 // Append m= attributes
2225 sdp_with_data.append(kSdpSctpDataChannelString);
2226 // Append a=sctp-port attribute
2227 sdp_with_data.append("a=sctp-port 5000\r\n");
2228 JsepSessionDescription jdesc_output(kDummyString);
2229
2230 EXPECT_FALSE(SdpDeserialize(sdp_with_data, &jdesc_output));
2231 }
2232
2233 // For crbug/344475.
2234 TEST_F(WebRtcSdpTest, DeserializeSdpWithCorruptedSctpDataChannels) {
2235 std::string sdp_with_data = kSdpString;
2236 sdp_with_data.append(kSdpSctpDataChannelString);
2237 // Remove the "\n" at the end.
2238 sdp_with_data = sdp_with_data.substr(0, sdp_with_data.size() - 1);
2239 JsepSessionDescription jdesc_output(kDummyString);
2240
2241 EXPECT_FALSE(SdpDeserialize(sdp_with_data, &jdesc_output));
2242 // No crash is a pass.
2243 }
2244
2245 TEST_F(WebRtcSdpTest, DeserializeSdpWithSctpDataChannelAndNewPort) {
2246 AddSctpDataChannel();
2247 const uint16_t kUnusualSctpPort = 9556;
2248 char default_portstr[16];
2249 char unusual_portstr[16];
2250 rtc::sprintfn(default_portstr, sizeof(default_portstr), "%d",
2251 kDefaultSctpPort);
2252 rtc::sprintfn(unusual_portstr, sizeof(unusual_portstr), "%d",
2253 kUnusualSctpPort);
2254
2255 // First setup the expected JsepSessionDescription.
2256 JsepSessionDescription jdesc(kDummyString);
2257 // take our pre-built session description and change the SCTP port.
2258 cricket::SessionDescription* mutant = desc_.Copy();
2259 DataContentDescription* dcdesc = static_cast<DataContentDescription*>(
2260 mutant->GetContentDescriptionByName(kDataContentName));
2261 std::vector<cricket::DataCodec> codecs(dcdesc->codecs());
2262 EXPECT_EQ(1U, codecs.size());
2263 EXPECT_EQ(cricket::kGoogleSctpDataCodecId, codecs[0].id);
2264 codecs[0].SetParam(cricket::kCodecParamPort, kUnusualSctpPort);
2265 dcdesc->set_codecs(codecs);
2266
2267 // note: mutant's owned by jdesc now.
2268 ASSERT_TRUE(jdesc.Initialize(mutant, kSessionId, kSessionVersion));
2269 mutant = NULL;
2270
2271 // Then get the deserialized JsepSessionDescription.
2272 std::string sdp_with_data = kSdpString;
2273 sdp_with_data.append(kSdpSctpDataChannelString);
2274 rtc::replace_substrs(default_portstr, strlen(default_portstr),
2275 unusual_portstr, strlen(unusual_portstr),
2276 &sdp_with_data);
2277 JsepSessionDescription jdesc_output(kDummyString);
2278
2279 EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
2280 EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
2281
2282 // We need to test the deserialized JsepSessionDescription from
2283 // kSdpSctpDataChannelStringWithSctpPort for
2284 // draft-ietf-mmusic-sctp-sdp-07
2285 // a=sctp-port
2286 sdp_with_data = kSdpString;
2287 sdp_with_data.append(kSdpSctpDataChannelStringWithSctpPort);
2288 rtc::replace_substrs(default_portstr, strlen(default_portstr),
2289 unusual_portstr, strlen(unusual_portstr),
2290 &sdp_with_data);
2291
2292 EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
2293 EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output));
2294 }
2295
2296 TEST_F(WebRtcSdpTest, DeserializeSdpWithRtpDataChannelsAndBandwidth) {
2297 // We want to test that deserializing data content limits bandwidth
2298 // settings (it should never be greater than the default).
2299 // This should prevent someone from using unlimited data bandwidth through
2300 // JS and "breaking the Internet".
2301 // See: https://code.google.com/p/chromium/issues/detail?id=280726
2302 std::string sdp_with_bandwidth = kSdpString;
2303 sdp_with_bandwidth.append(kSdpRtpDataChannelString);
2304 InjectAfter("a=mid:data_content_name\r\n",
2305 "b=AS:100\r\n",
2306 &sdp_with_bandwidth);
2307 JsepSessionDescription jdesc_with_bandwidth(kDummyString);
2308
2309 EXPECT_FALSE(SdpDeserialize(sdp_with_bandwidth, &jdesc_with_bandwidth));
2310 }
2311
2312 TEST_F(WebRtcSdpTest, DeserializeSdpWithSctpDataChannelsAndBandwidth) {
2313 AddSctpDataChannel();
2314 JsepSessionDescription jdesc(kDummyString);
2315 DataContentDescription* dcd = static_cast<DataContentDescription*>(
2316 GetFirstDataContent(&desc_)->description);
2317 dcd->set_bandwidth(100 * 1000);
2318 ASSERT_TRUE(jdesc.Initialize(desc_.Copy(), kSessionId, kSessionVersion));
2319
2320 std::string sdp_with_bandwidth = kSdpString;
2321 sdp_with_bandwidth.append(kSdpSctpDataChannelString);
2322 InjectAfter("a=mid:data_content_name\r\n",
2323 "b=AS:100\r\n",
2324 &sdp_with_bandwidth);
2325 JsepSessionDescription jdesc_with_bandwidth(kDummyString);
2326
2327 // SCTP has congestion control, so we shouldn't limit the bandwidth
2328 // as we do for RTP.
2329 EXPECT_TRUE(SdpDeserialize(sdp_with_bandwidth, &jdesc_with_bandwidth));
2330 EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_with_bandwidth));
2331 }
2332
2333 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithSessionLevelExtmap) {
2334 TestDeserializeExtmap(true, false);
2335 }
2336
2337 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithMediaLevelExtmap) {
2338 TestDeserializeExtmap(false, true);
2339 }
2340
2341 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithInvalidExtmap) {
2342 TestDeserializeExtmap(true, true);
2343 }
2344
2345 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithoutEndLineBreak) {
2346 JsepSessionDescription jdesc(kDummyString);
2347 std::string sdp = kSdpFullString;
2348 sdp = sdp.substr(0, sdp.size() - 2); // Remove \r\n at the end.
2349 // Deserialize
2350 SdpParseError error;
2351 EXPECT_FALSE(webrtc::SdpDeserialize(sdp, &jdesc, &error));
2352 const std::string lastline = "a=ssrc:6 label:video_track_id_3";
2353 EXPECT_EQ(lastline, error.line);
2354 EXPECT_EQ("Invalid SDP line.", error.description);
2355 }
2356
2357 TEST_F(WebRtcSdpTest, DeserializeCandidateWithDifferentTransport) {
2358 JsepIceCandidate jcandidate(kDummyMid, kDummyIndex);
2359 std::string new_sdp = kSdpOneCandidate;
2360 Replace("udp", "unsupported_transport", &new_sdp);
2361 EXPECT_FALSE(SdpDeserializeCandidate(new_sdp, &jcandidate));
2362 new_sdp = kSdpOneCandidate;
2363 Replace("udp", "uDP", &new_sdp);
2364 EXPECT_TRUE(SdpDeserializeCandidate(new_sdp, &jcandidate));
2365 EXPECT_EQ(kDummyMid, jcandidate.sdp_mid());
2366 EXPECT_EQ(kDummyIndex, jcandidate.sdp_mline_index());
2367 EXPECT_TRUE(jcandidate.candidate().IsEquivalent(jcandidate_->candidate()));
2368 }
2369
2370 TEST_F(WebRtcSdpTest, DeserializeCandidateWithUfragPwd) {
2371 JsepIceCandidate jcandidate(kDummyMid, kDummyIndex);
2372 EXPECT_TRUE(
2373 SdpDeserializeCandidate(kSdpOneCandidateWithUfragPwd, &jcandidate));
2374 EXPECT_EQ(kDummyMid, jcandidate.sdp_mid());
2375 EXPECT_EQ(kDummyIndex, jcandidate.sdp_mline_index());
2376 Candidate ref_candidate = jcandidate_->candidate();
2377 ref_candidate.set_username("user_rtp");
2378 ref_candidate.set_password("password_rtp");
2379 EXPECT_TRUE(jcandidate.candidate().IsEquivalent(ref_candidate));
2380 }
2381
2382 TEST_F(WebRtcSdpTest, DeserializeSdpWithConferenceFlag) {
2383 JsepSessionDescription jdesc(kDummyString);
2384
2385 // Deserialize
2386 EXPECT_TRUE(SdpDeserialize(kSdpConferenceString, &jdesc));
2387
2388 // Verify
2389 cricket::AudioContentDescription* audio =
2390 static_cast<AudioContentDescription*>(
2391 jdesc.description()->GetContentDescriptionByName(cricket::CN_AUDIO));
2392 EXPECT_TRUE(audio->conference_mode());
2393
2394 cricket::VideoContentDescription* video =
2395 static_cast<VideoContentDescription*>(
2396 jdesc.description()->GetContentDescriptionByName(cricket::CN_VIDEO));
2397 EXPECT_TRUE(video->conference_mode());
2398 }
2399
2400 TEST_F(WebRtcSdpTest, DeserializeBrokenSdp) {
2401 const char kSdpDestroyer[] = "!@#$%^&";
2402 const char kSdpEmptyType[] = " =candidate";
2403 const char kSdpEqualAsPlus[] = "a+candidate";
2404 const char kSdpSpaceAfterEqual[] = "a= candidate";
2405 const char kSdpUpperType[] = "A=candidate";
2406 const char kSdpEmptyLine[] = "";
2407 const char kSdpMissingValue[] = "a=";
2408
2409 const char kSdpBrokenFingerprint[] = "a=fingerprint:sha-1 "
2410 "4AAD:B9:B1:3F:82:18:3B:54:02:12:DF:3E:5D:49:6B:19:E5:7C:AB";
2411 const char kSdpExtraField[] = "a=fingerprint:sha-1 "
2412 "4A:AD:B9:B1:3F:82:18:3B:54:02:12:DF:3E:5D:49:6B:19:E5:7C:AB XXX";
2413 const char kSdpMissingSpace[] = "a=fingerprint:sha-1"
2414 "4A:AD:B9:B1:3F:82:18:3B:54:02:12:DF:3E:5D:49:6B:19:E5:7C:AB";
2415 // MD5 is not allowed in fingerprints.
2416 const char kSdpMd5[] = "a=fingerprint:md5 "
2417 "4A:AD:B9:B1:3F:82:18:3B:54:02:12:DF:3E:5D:49:6B";
2418
2419 // Broken session description
2420 ExpectParseFailure("v=", kSdpDestroyer);
2421 ExpectParseFailure("o=", kSdpDestroyer);
2422 ExpectParseFailure("s=-", kSdpDestroyer);
2423 // Broken time description
2424 ExpectParseFailure("t=", kSdpDestroyer);
2425
2426 // Broken media description
2427 ExpectParseFailure("m=audio", "c=IN IP4 74.125.224.39");
2428 ExpectParseFailure("m=video", kSdpDestroyer);
2429
2430 // Invalid lines
2431 ExpectParseFailure("a=candidate", kSdpEmptyType);
2432 ExpectParseFailure("a=candidate", kSdpEqualAsPlus);
2433 ExpectParseFailure("a=candidate", kSdpSpaceAfterEqual);
2434 ExpectParseFailure("a=candidate", kSdpUpperType);
2435
2436 // Bogus fingerprint replacing a=sendrev. We selected this attribute
2437 // because it's orthogonal to what we are replacing and hence
2438 // safe.
2439 ExpectParseFailure("a=sendrecv", kSdpBrokenFingerprint);
2440 ExpectParseFailure("a=sendrecv", kSdpExtraField);
2441 ExpectParseFailure("a=sendrecv", kSdpMissingSpace);
2442 ExpectParseFailure("a=sendrecv", kSdpMd5);
2443
2444 // Empty Line
2445 ExpectParseFailure("a=rtcp:2347 IN IP4 74.125.127.126", kSdpEmptyLine);
2446 ExpectParseFailure("a=rtcp:2347 IN IP4 74.125.127.126", kSdpMissingValue);
2447 }
2448
2449 TEST_F(WebRtcSdpTest, DeserializeSdpWithInvalidAttributeValue) {
2450 // ssrc
2451 ExpectParseFailure("a=ssrc:1", "a=ssrc:badvalue");
2452 ExpectParseFailure("a=ssrc-group:FEC 5 6", "a=ssrc-group:FEC badvalue 6");
2453 // crypto
2454 ExpectParseFailure("a=crypto:1 ", "a=crypto:badvalue ");
2455 // rtpmap
2456 ExpectParseFailure("a=rtpmap:111 ", "a=rtpmap:badvalue ");
2457 ExpectParseFailure("opus/48000/2", "opus/badvalue/2");
2458 ExpectParseFailure("opus/48000/2", "opus/48000/badvalue");
2459 // candidate
2460 ExpectParseFailure("1 udp 2130706432", "badvalue udp 2130706432");
2461 ExpectParseFailure("1 udp 2130706432", "1 udp badvalue");
2462 ExpectParseFailure("192.168.1.5 1234", "192.168.1.5 badvalue");
2463 ExpectParseFailure("rport 2346", "rport badvalue");
2464 ExpectParseFailure("rport 2346 generation 2",
2465 "rport 2346 generation badvalue");
2466 // m line
2467 ExpectParseFailure("m=audio 2345 RTP/SAVPF 111 103 104",
2468 "m=audio 2345 RTP/SAVPF 111 badvalue 104");
2469
2470 // bandwidth
2471 ExpectParseFailureWithNewLines("a=mid:video_content_name\r\n",
2472 "b=AS:badvalue\r\n",
2473 "b=AS:badvalue");
2474 // rtcp-fb
2475 ExpectParseFailureWithNewLines("a=mid:video_content_name\r\n",
2476 "a=rtcp-fb:badvalue nack\r\n",
2477 "a=rtcp-fb:badvalue nack");
2478 // extmap
2479 ExpectParseFailureWithNewLines("a=mid:video_content_name\r\n",
2480 "a=extmap:badvalue http://example.com\r\n",
2481 "a=extmap:badvalue http://example.com");
2482 }
2483
2484 TEST_F(WebRtcSdpTest, DeserializeSdpWithReorderedPltypes) {
2485 JsepSessionDescription jdesc_output(kDummyString);
2486
2487 const char kSdpWithReorderedPlTypesString[] =
2488 "v=0\r\n"
2489 "o=- 18446744069414584320 18446462598732840960 IN IP4 127.0.0.1\r\n"
2490 "s=-\r\n"
2491 "t=0 0\r\n"
2492 "m=audio 9 RTP/SAVPF 104 103\r\n" // Pl type 104 preferred.
2493 "a=rtpmap:111 opus/48000/2\r\n" // Pltype 111 listed before 103 and 104
2494 // in the map.
2495 "a=rtpmap:103 ISAC/16000\r\n" // Pltype 103 listed before 104 in the map.
2496 "a=rtpmap:104 ISAC/32000\r\n";
2497
2498 // Deserialize
2499 EXPECT_TRUE(SdpDeserialize(kSdpWithReorderedPlTypesString, &jdesc_output));
2500
2501 const ContentInfo* ac = GetFirstAudioContent(jdesc_output.description());
2502 ASSERT_TRUE(ac != NULL);
2503 const AudioContentDescription* acd =
2504 static_cast<const AudioContentDescription*>(ac->description);
2505 ASSERT_FALSE(acd->codecs().empty());
2506 EXPECT_EQ("ISAC", acd->codecs()[0].name);
2507 EXPECT_EQ(32000, acd->codecs()[0].clockrate);
2508 EXPECT_EQ(104, acd->codecs()[0].id);
2509 }
2510
2511 TEST_F(WebRtcSdpTest, DeserializeSerializeCodecParams) {
2512 JsepSessionDescription jdesc_output(kDummyString);
2513 CodecParams params;
2514 params.max_ptime = 40;
2515 params.ptime = 30;
2516 params.min_ptime = 10;
2517 params.sprop_stereo = 1;
2518 params.stereo = 1;
2519 params.useinband = 1;
2520 params.maxaveragebitrate = 128000;
2521 TestDeserializeCodecParams(params, &jdesc_output);
2522 TestSerialize(jdesc_output);
2523 }
2524
2525 TEST_F(WebRtcSdpTest, DeserializeSerializeRtcpFb) {
2526 const bool kUseWildcard = false;
2527 JsepSessionDescription jdesc_output(kDummyString);
2528 TestDeserializeRtcpFb(&jdesc_output, kUseWildcard);
2529 TestSerialize(jdesc_output);
2530 }
2531
2532 TEST_F(WebRtcSdpTest, DeserializeSerializeRtcpFbWildcard) {
2533 const bool kUseWildcard = true;
2534 JsepSessionDescription jdesc_output(kDummyString);
2535 TestDeserializeRtcpFb(&jdesc_output, kUseWildcard);
2536 TestSerialize(jdesc_output);
2537 }
2538
2539 TEST_F(WebRtcSdpTest, DeserializeVideoFmtp) {
2540 JsepSessionDescription jdesc_output(kDummyString);
2541
2542 const char kSdpWithFmtpString[] =
2543 "v=0\r\n"
2544 "o=- 18446744069414584320 18446462598732840960 IN IP4 127.0.0.1\r\n"
2545 "s=-\r\n"
2546 "t=0 0\r\n"
2547 "m=video 3457 RTP/SAVPF 120\r\n"
2548 "a=rtpmap:120 VP8/90000\r\n"
2549 "a=fmtp:120 x-google-min-bitrate=10;x-google-max-quantization=40\r\n";
2550
2551 // Deserialize
2552 SdpParseError error;
2553 EXPECT_TRUE(
2554 webrtc::SdpDeserialize(kSdpWithFmtpString, &jdesc_output, &error));
2555
2556 const ContentInfo* vc = GetFirstVideoContent(jdesc_output.description());
2557 ASSERT_TRUE(vc != NULL);
2558 const VideoContentDescription* vcd =
2559 static_cast<const VideoContentDescription*>(vc->description);
2560 ASSERT_FALSE(vcd->codecs().empty());
2561 cricket::VideoCodec vp8 = vcd->codecs()[0];
2562 EXPECT_EQ("VP8", vp8.name);
2563 EXPECT_EQ(120, vp8.id);
2564 cricket::CodecParameterMap::iterator found =
2565 vp8.params.find("x-google-min-bitrate");
2566 ASSERT_TRUE(found != vp8.params.end());
2567 EXPECT_EQ(found->second, "10");
2568 found = vp8.params.find("x-google-max-quantization");
2569 ASSERT_TRUE(found != vp8.params.end());
2570 EXPECT_EQ(found->second, "40");
2571 }
2572
2573 TEST_F(WebRtcSdpTest, DeserializeVideoFmtpWithSpace) {
2574 JsepSessionDescription jdesc_output(kDummyString);
2575
2576 const char kSdpWithFmtpString[] =
2577 "v=0\r\n"
2578 "o=- 18446744069414584320 18446462598732840960 IN IP4 127.0.0.1\r\n"
2579 "s=-\r\n"
2580 "t=0 0\r\n"
2581 "m=video 3457 RTP/SAVPF 120\r\n"
2582 "a=rtpmap:120 VP8/90000\r\n"
2583 "a=fmtp:120 x-google-min-bitrate=10; x-google-max-quantization=40\r\n";
2584
2585 // Deserialize
2586 SdpParseError error;
2587 EXPECT_TRUE(webrtc::SdpDeserialize(kSdpWithFmtpString, &jdesc_output,
2588 &error));
2589
2590 const ContentInfo* vc = GetFirstVideoContent(jdesc_output.description());
2591 ASSERT_TRUE(vc != NULL);
2592 const VideoContentDescription* vcd =
2593 static_cast<const VideoContentDescription*>(vc->description);
2594 ASSERT_FALSE(vcd->codecs().empty());
2595 cricket::VideoCodec vp8 = vcd->codecs()[0];
2596 EXPECT_EQ("VP8", vp8.name);
2597 EXPECT_EQ(120, vp8.id);
2598 cricket::CodecParameterMap::iterator found =
2599 vp8.params.find("x-google-min-bitrate");
2600 ASSERT_TRUE(found != vp8.params.end());
2601 EXPECT_EQ(found->second, "10");
2602 found = vp8.params.find("x-google-max-quantization");
2603 ASSERT_TRUE(found != vp8.params.end());
2604 EXPECT_EQ(found->second, "40");
2605 }
2606
2607 TEST_F(WebRtcSdpTest, SerializeVideoFmtp) {
2608 VideoContentDescription* vcd = static_cast<VideoContentDescription*>(
2609 GetFirstVideoContent(&desc_)->description);
2610
2611 cricket::VideoCodecs codecs = vcd->codecs();
2612 codecs[0].params["x-google-min-bitrate"] = "10";
2613 vcd->set_codecs(codecs);
2614
2615 ASSERT_TRUE(jdesc_.Initialize(desc_.Copy(),
2616 jdesc_.session_id(),
2617 jdesc_.session_version()));
2618 std::string message = webrtc::SdpSerialize(jdesc_);
2619 std::string sdp_with_fmtp = kSdpFullString;
2620 InjectAfter("a=rtpmap:120 VP8/90000\r\n",
2621 "a=fmtp:120 x-google-min-bitrate=10\r\n",
2622 &sdp_with_fmtp);
2623 EXPECT_EQ(sdp_with_fmtp, message);
2624 }
2625
2626 TEST_F(WebRtcSdpTest, DeserializeSdpWithIceLite) {
2627 JsepSessionDescription jdesc_with_icelite(kDummyString);
2628 std::string sdp_with_icelite = kSdpFullString;
2629 EXPECT_TRUE(SdpDeserialize(sdp_with_icelite, &jdesc_with_icelite));
2630 cricket::SessionDescription* desc = jdesc_with_icelite.description();
2631 const cricket::TransportInfo* tinfo1 =
2632 desc->GetTransportInfoByName("audio_content_name");
2633 EXPECT_EQ(cricket::ICEMODE_FULL, tinfo1->description.ice_mode);
2634 const cricket::TransportInfo* tinfo2 =
2635 desc->GetTransportInfoByName("video_content_name");
2636 EXPECT_EQ(cricket::ICEMODE_FULL, tinfo2->description.ice_mode);
2637 InjectAfter(kSessionTime,
2638 "a=ice-lite\r\n",
2639 &sdp_with_icelite);
2640 EXPECT_TRUE(SdpDeserialize(sdp_with_icelite, &jdesc_with_icelite));
2641 desc = jdesc_with_icelite.description();
2642 const cricket::TransportInfo* atinfo =
2643 desc->GetTransportInfoByName("audio_content_name");
2644 EXPECT_EQ(cricket::ICEMODE_LITE, atinfo->description.ice_mode);
2645 const cricket::TransportInfo* vtinfo =
2646 desc->GetTransportInfoByName("video_content_name");
2647 EXPECT_EQ(cricket::ICEMODE_LITE, vtinfo->description.ice_mode);
2648 }
2649
2650 // Verifies that the candidates in the input SDP are parsed and serialized
2651 // correctly in the output SDP.
2652 TEST_F(WebRtcSdpTest, RoundTripSdpWithSctpDataChannelsWithCandidates) {
2653 std::string sdp_with_data = kSdpString;
2654 sdp_with_data.append(kSdpSctpDataChannelWithCandidatesString);
2655 JsepSessionDescription jdesc_output(kDummyString);
2656
2657 EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
2658 EXPECT_EQ(sdp_with_data, webrtc::SdpSerialize(jdesc_output));
2659 }
2660
2661 TEST_F(WebRtcSdpTest, SerializeDtlsSetupAttribute) {
2662 AddFingerprint();
2663 TransportInfo audio_transport_info =
2664 *(desc_.GetTransportInfoByName(kAudioContentName));
2665 EXPECT_EQ(cricket::CONNECTIONROLE_NONE,
2666 audio_transport_info.description.connection_role);
2667 audio_transport_info.description.connection_role =
2668 cricket::CONNECTIONROLE_ACTIVE;
2669
2670 TransportInfo video_transport_info =
2671 *(desc_.GetTransportInfoByName(kVideoContentName));
2672 EXPECT_EQ(cricket::CONNECTIONROLE_NONE,
2673 video_transport_info.description.connection_role);
2674 video_transport_info.description.connection_role =
2675 cricket::CONNECTIONROLE_ACTIVE;
2676
2677 desc_.RemoveTransportInfoByName(kAudioContentName);
2678 desc_.RemoveTransportInfoByName(kVideoContentName);
2679
2680 desc_.AddTransportInfo(audio_transport_info);
2681 desc_.AddTransportInfo(video_transport_info);
2682
2683 ASSERT_TRUE(jdesc_.Initialize(desc_.Copy(),
2684 jdesc_.session_id(),
2685 jdesc_.session_version()));
2686 std::string message = webrtc::SdpSerialize(jdesc_);
2687 std::string sdp_with_dtlssetup = kSdpFullString;
2688
2689 // Fingerprint attribute is necessary to add DTLS setup attribute.
2690 InjectAfter(kAttributeIcePwdVoice,
2691 kFingerprint, &sdp_with_dtlssetup);
2692 InjectAfter(kAttributeIcePwdVideo,
2693 kFingerprint, &sdp_with_dtlssetup);
2694 // Now adding |setup| attribute.
2695 InjectAfter(kFingerprint,
2696 "a=setup:active\r\n", &sdp_with_dtlssetup);
2697 EXPECT_EQ(sdp_with_dtlssetup, message);
2698 }
2699
2700 TEST_F(WebRtcSdpTest, DeserializeDtlsSetupAttribute) {
2701 JsepSessionDescription jdesc_with_dtlssetup(kDummyString);
2702 std::string sdp_with_dtlssetup = kSdpFullString;
2703 InjectAfter(kSessionTime,
2704 "a=setup:actpass\r\n",
2705 &sdp_with_dtlssetup);
2706 EXPECT_TRUE(SdpDeserialize(sdp_with_dtlssetup, &jdesc_with_dtlssetup));
2707 cricket::SessionDescription* desc = jdesc_with_dtlssetup.description();
2708 const cricket::TransportInfo* atinfo =
2709 desc->GetTransportInfoByName("audio_content_name");
2710 EXPECT_EQ(cricket::CONNECTIONROLE_ACTPASS,
2711 atinfo->description.connection_role);
2712 const cricket::TransportInfo* vtinfo =
2713 desc->GetTransportInfoByName("video_content_name");
2714 EXPECT_EQ(cricket::CONNECTIONROLE_ACTPASS,
2715 vtinfo->description.connection_role);
2716 }
2717
2718 // Verifies that the order of the serialized m-lines follows the order of the
2719 // ContentInfo in SessionDescription, and vise versa for deserialization.
2720 TEST_F(WebRtcSdpTest, MediaContentOrderMaintainedRoundTrip) {
2721 JsepSessionDescription jdesc(kDummyString);
2722 const std::string media_content_sdps[3] = {
2723 kSdpAudioString,
2724 kSdpVideoString,
2725 kSdpSctpDataChannelString
2726 };
2727 const cricket::MediaType media_types[3] = {
2728 cricket::MEDIA_TYPE_AUDIO,
2729 cricket::MEDIA_TYPE_VIDEO,
2730 cricket::MEDIA_TYPE_DATA
2731 };
2732
2733 // Verifies all 6 permutations.
2734 for (size_t i = 0; i < 6; ++i) {
2735 size_t media_content_in_sdp[3];
2736 // The index of the first media content.
2737 media_content_in_sdp[0] = i / 2;
2738 // The index of the second media content.
2739 media_content_in_sdp[1] = (media_content_in_sdp[0] + i % 2 + 1) % 3;
2740 // The index of the third media content.
2741 media_content_in_sdp[2] = (media_content_in_sdp[0] + (i + 1) % 2 + 1) % 3;
2742
2743 std::string sdp_string = kSdpSessionString;
2744 for (size_t i = 0; i < 3; ++i)
2745 sdp_string += media_content_sdps[media_content_in_sdp[i]];
2746
2747 EXPECT_TRUE(SdpDeserialize(sdp_string, &jdesc));
2748 cricket::SessionDescription* desc = jdesc.description();
2749 EXPECT_EQ(3u, desc->contents().size());
2750
2751 for (size_t i = 0; i < 3; ++i) {
2752 const cricket::MediaContentDescription* mdesc =
2753 static_cast<const cricket::MediaContentDescription*>(
2754 desc->contents()[i].description);
2755 EXPECT_EQ(media_types[media_content_in_sdp[i]], mdesc->type());
2756 }
2757
2758 std::string serialized_sdp = webrtc::SdpSerialize(jdesc);
2759 EXPECT_EQ(sdp_string, serialized_sdp);
2760 }
2761 }
OLDNEW
« no previous file with comments | « talk/app/webrtc/webrtcsdp.cc ('k') | talk/app/webrtc/webrtcsession.h » ('j') | talk/libjingle.gyp » ('J')

Powered by Google App Engine
This is Rietveld 408576698