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
48using cricket::AudioCodec;
49using cricket::AudioContentDescription;
50using cricket::Candidate;
51using cricket::ContentInfo;
52using cricket::CryptoParams;
53using cricket::ContentGroup;
54using cricket::DataCodec;
55using cricket::DataContentDescription;
56using cricket::ICE_CANDIDATE_COMPONENT_RTCP;
57using cricket::ICE_CANDIDATE_COMPONENT_RTP;
58using cricket::kFecSsrcGroupSemantics;
59using cricket::LOCAL_PORT_TYPE;
60using cricket::NS_JINGLE_DRAFT_SCTP;
61using cricket::NS_JINGLE_RTP;
62using cricket::RtpHeaderExtension;
63using cricket::RELAY_PORT_TYPE;
64using cricket::SessionDescription;
65using cricket::StreamParams;
66using cricket::STUN_PORT_TYPE;
67using cricket::TransportDescription;
68using cricket::TransportInfo;
69using cricket::VideoCodec;
70using cricket::VideoContentDescription;
71using webrtc::IceCandidateCollection;
72using webrtc::IceCandidateInterface;
73using webrtc::JsepIceCandidate;
74using webrtc::JsepSessionDescription;
75using webrtc::SdpParseError;
76using webrtc::SessionDescriptionInterface;
77
78typedef std::vector<AudioCodec> AudioCodecs;
79typedef std::vector<Candidate> Candidates;
80
81static const uint32_t kDefaultSctpPort = 5000;
82static const char kSessionTime[] = "t=0 0\r\n";
83static const uint32_t kCandidatePriority = 2130706432U;  // pref = 1.0
84static const char kCandidateUfragVoice[] = "ufrag_voice";
85static const char kCandidatePwdVoice[] = "pwd_voice";
86static const char kAttributeIceUfragVoice[] = "a=ice-ufrag:ufrag_voice\r\n";
87static const char kAttributeIcePwdVoice[] = "a=ice-pwd:pwd_voice\r\n";
88static const char kCandidateUfragVideo[] = "ufrag_video";
89static const char kCandidatePwdVideo[] = "pwd_video";
90static const char kCandidateUfragData[] = "ufrag_data";
91static const char kCandidatePwdData[] = "pwd_data";
92static const char kAttributeIceUfragVideo[] = "a=ice-ufrag:ufrag_video\r\n";
93static const char kAttributeIcePwdVideo[] = "a=ice-pwd:pwd_video\r\n";
94static const uint32_t kCandidateGeneration = 2;
95static const char kCandidateFoundation1[] = "a0+B/1";
96static const char kCandidateFoundation2[] = "a0+B/2";
97static const char kCandidateFoundation3[] = "a0+B/3";
98static const char kCandidateFoundation4[] = "a0+B/4";
99static 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";
103static const char kAttributeCryptoVideo[] =
104    "a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
105    "inline:d0RmdmcmVCspeEc3QGZiNWpVLFJhQX1cfHAwJSoj|2^20|1:32\r\n";
106static 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";
108static const int kExtmapId = 1;
109static const char kExtmapUri[] = "http://example.com/082005/ext.htm#ttime";
110static const char kExtmap[] =
111    "a=extmap:1 http://example.com/082005/ext.htm#ttime\r\n";
112static const char kExtmapWithDirectionAndAttribute[] =
113    "a=extmap:1/sendrecv http://example.com/082005/ext.htm#ttime a1 a2\r\n";
114
115static 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
119static const char kDtlsSctp[] = "DTLS/SCTP";
120static const char kUdpDtlsSctp[] = "UDP/DTLS/SCTP";
121static const char kTcpDtlsSctp[] = "TCP/DTLS/SCTP";
122
123struct 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
134static 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.
216static 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
271static 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
287static 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
296static 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
305static 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
314static 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
329static 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
342static 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
349static 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
362static 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
378static 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.
381static 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
385static const char kSdpTcpActiveCandidate[] =
386    "candidate:a0+B/1 1 tcp 2130706432 192.168.1.5 9 typ host "
387    "tcptype active generation 2";
388static const char kSdpTcpPassiveCandidate[] =
389    "candidate:a0+B/1 1 tcp 2130706432 192.168.1.5 9 typ host "
390    "tcptype passive generation 2";
391static const char kSdpTcpSOCandidate[] =
392    "candidate:a0+B/1 1 tcp 2130706432 192.168.1.5 9 typ host "
393    "tcptype so generation 2";
394static 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.
399static 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.
404static 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
409static const char kSessionId[] = "18446744069414584320";
410static const char kSessionVersion[] = "18446462598732840960";
411
412// Ice options
413static const char kIceOption1[] = "iceoption1";
414static const char kIceOption2[] = "iceoption2";
415static const char kIceOption3[] = "iceoption3";
416
417// Content name
418static const char kAudioContentName[] = "audio_content_name";
419static const char kVideoContentName[] = "video_content_name";
420static const char kDataContentName[] = "data_content_name";
421
422// MediaStream 1
423static const char kStreamLabel1[] = "local_stream_1";
424static const char kStream1Cname[] = "stream_1_cname";
425static const char kAudioTrackId1[] = "audio_track_id_1";
426static const uint32_t kAudioTrack1Ssrc = 1;
427static const char kVideoTrackId1[] = "video_track_id_1";
428static const uint32_t kVideoTrack1Ssrc = 2;
429static const char kVideoTrackId2[] = "video_track_id_2";
430static const uint32_t kVideoTrack2Ssrc = 3;
431
432// MediaStream 2
433static const char kStreamLabel2[] = "local_stream_2";
434static const char kStream2Cname[] = "stream_2_cname";
435static const char kAudioTrackId2[] = "audio_track_id_2";
436static const uint32_t kAudioTrack2Ssrc = 4;
437static const char kVideoTrackId3[] = "video_track_id_3";
438static const uint32_t kVideoTrack3Ssrc = 5;
439static const uint32_t kVideoTrack4Ssrc = 6;
440
441// DataChannel
442static const char kDataChannelLabel[] = "data_channel";
443static const char kDataChannelMsid[] = "data_channeld0";
444static const char kDataChannelCname[] = "data_channel_cname";
445static const uint32_t kDataChannelSsrc = 10;
446
447// Candidate
448static const char kDummyMid[] = "dummy_mid";
449static const int kDummyIndex = 123;
450
451// Misc
452static const char kDummyString[] = "dummy";
453
454// Helper functions
455
456static bool SdpDeserialize(const std::string& message,
457                           JsepSessionDescription* jdesc) {
458  return webrtc::SdpDeserialize(message, jdesc, NULL);
459}
460
461static 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|.
467static 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
475static 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.
484static 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|.
494static 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|.
501static 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
509static 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
530static 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
546class 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
1398void 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
1412TEST_F(WebRtcSdpTest, SerializeSessionDescription) {
1413  // SessionDescription with desc and candidates.
1414  std::string message = webrtc::SdpSerialize(jdesc_);
1415  TestMismatch(std::string(kSdpFullString), message);
1416}
1417
1418TEST_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.
1425TEST_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.
1456TEST_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.
1486TEST_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.
1518TEST_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.
1546TEST_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.
1564TEST_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
1583TEST_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
1592TEST_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
1608TEST_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
1629TEST_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
1652TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithRecvOnlyContent) {
1653  EXPECT_TRUE(TestSerializeDirection(cricket::MD_RECVONLY));
1654}
1655
1656TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithSendOnlyContent) {
1657  EXPECT_TRUE(TestSerializeDirection(cricket::MD_SENDONLY));
1658}
1659
1660TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithInactiveContent) {
1661  EXPECT_TRUE(TestSerializeDirection(cricket::MD_INACTIVE));
1662}
1663
1664TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithAudioRejected) {
1665  EXPECT_TRUE(TestSerializeRejected(true, false));
1666}
1667
1668TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithVideoRejected) {
1669  EXPECT_TRUE(TestSerializeRejected(false, true));
1670}
1671
1672TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithAudioVideoRejected) {
1673  EXPECT_TRUE(TestSerializeRejected(true, true));
1674}
1675
1676TEST_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
1688TEST_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
1700TEST_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
1731TEST_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
1748TEST_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
1764TEST_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.
1778TEST_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
1791TEST_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
1799TEST_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
1812TEST_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
1822TEST_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
1832TEST_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
1858TEST_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.
1890TEST_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
1906TEST_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
1923TEST_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
1946TEST_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
1973TEST_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
1996TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithRecvOnlyContent) {
1997  EXPECT_TRUE(TestDeserializeDirection(cricket::MD_RECVONLY));
1998}
1999
2000TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithSendOnlyContent) {
2001  EXPECT_TRUE(TestDeserializeDirection(cricket::MD_SENDONLY));
2002}
2003
2004TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithInactiveContent) {
2005  EXPECT_TRUE(TestDeserializeDirection(cricket::MD_INACTIVE));
2006}
2007
2008TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithRejectedAudio) {
2009  EXPECT_TRUE(TestDeserializeRejected(true, false));
2010}
2011
2012TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithRejectedVideo) {
2013  EXPECT_TRUE(TestDeserializeRejected(false, true));
2014}
2015
2016TEST_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.
2022TEST_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
2033TEST_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.
2073TEST_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.
2104TEST_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
2123TEST_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
2138TEST_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
2164TEST_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
2190TEST_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.
2218TEST_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.
2234TEST_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
2245TEST_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
2296TEST_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
2312TEST_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
2333TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithSessionLevelExtmap) {
2334  TestDeserializeExtmap(true, false);
2335}
2336
2337TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithMediaLevelExtmap) {
2338  TestDeserializeExtmap(false, true);
2339}
2340
2341TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithInvalidExtmap) {
2342  TestDeserializeExtmap(true, true);
2343}
2344
2345TEST_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
2357TEST_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
2370TEST_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
2382TEST_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
2400TEST_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
2449TEST_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
2484TEST_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
2511TEST_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
2525TEST_F(WebRtcSdpTest, DeserializeSerializeRtcpFb) {
2526  const bool kUseWildcard = false;
2527  JsepSessionDescription jdesc_output(kDummyString);
2528  TestDeserializeRtcpFb(&jdesc_output, kUseWildcard);
2529  TestSerialize(jdesc_output);
2530}
2531
2532TEST_F(WebRtcSdpTest, DeserializeSerializeRtcpFbWildcard) {
2533  const bool kUseWildcard = true;
2534  JsepSessionDescription jdesc_output(kDummyString);
2535  TestDeserializeRtcpFb(&jdesc_output, kUseWildcard);
2536  TestSerialize(jdesc_output);
2537}
2538
2539TEST_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
2573TEST_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
2607TEST_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
2626TEST_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.
2652TEST_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
2661TEST_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
2700TEST_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.
2720TEST_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}
2762