src/third_party/libjingle/source/talk/session/media/mediasession_unittest.cc

   1 /*
   2  * libjingle
   3  * Copyright 2004 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 <string>
  29 #include <vector>
  30
  31 #include "talk/media/base/codec.h"
  32 #include "talk/media/base/testutils.h"
  33 #include "talk/p2p/base/constants.h"
  34 #include "talk/p2p/base/transportdescription.h"
  35 #include "talk/p2p/base/transportinfo.h"
  36 #include "talk/session/media/mediasession.h"
  37 #include "talk/session/media/srtpfilter.h"
  38 #include "webrtc/base/fakesslidentity.h"
  39 #include "webrtc/base/gunit.h"
  40 #include "webrtc/base/messagedigest.h"
  41 #include "webrtc/base/ssladapter.h"
  42
  43 #ifdef HAVE_SRTP
  44 #define ASSERT_CRYPTO(cd, s, cs) \
  45     ASSERT_EQ(cricket::CT_NONE, cd->crypto_required()); \
  46     ASSERT_EQ(s, cd->cryptos().size()); \
  47     ASSERT_EQ(std::string(cs), cd->cryptos()[0].cipher_suite)
  48 #else
  49 #define ASSERT_CRYPTO(cd, s, cs) \
  50   ASSERT_EQ(cricket::CT_NONE, cd->crypto_required()); \
  51   ASSERT_EQ(0U, cd->cryptos().size());
  52 #endif
  53
  54 typedef std::vector<cricket::Candidate> Candidates;
  55
  56 using cricket::MediaContentDescription;
  57 using cricket::MediaSessionDescriptionFactory;
  58 using cricket::MediaSessionOptions;
  59 using cricket::MediaType;
  60 using cricket::SessionDescription;
  61 using cricket::SsrcGroup;
  62 using cricket::StreamParams;
  63 using cricket::StreamParamsVec;
  64 using cricket::TransportDescription;
  65 using cricket::TransportDescriptionFactory;
  66 using cricket::TransportInfo;
  67 using cricket::ContentInfo;
  68 using cricket::CryptoParamsVec;
  69 using cricket::AudioContentDescription;
  70 using cricket::VideoContentDescription;
  71 using cricket::DataContentDescription;
  72 using cricket::GetFirstAudioContentDescription;
  73 using cricket::GetFirstVideoContentDescription;
  74 using cricket::GetFirstDataContentDescription;
  75 using cricket::kAutoBandwidth;
  76 using cricket::AudioCodec;
  77 using cricket::VideoCodec;
  78 using cricket::DataCodec;
  79 using cricket::NS_JINGLE_RTP;
  80 using cricket::MEDIA_TYPE_AUDIO;
  81 using cricket::MEDIA_TYPE_VIDEO;
  82 using cricket::MEDIA_TYPE_DATA;
  83 using cricket::RtpHeaderExtension;
  84 using cricket::SEC_DISABLED;
  85 using cricket::SEC_ENABLED;
  86 using cricket::SEC_REQUIRED;
  87 using cricket::CS_AES_CM_128_HMAC_SHA1_32;
  88 using cricket::CS_AES_CM_128_HMAC_SHA1_80;
  89
  90 static const AudioCodec kAudioCodecs1[] = {
  91   AudioCodec(103, "ISAC",   16000, -1,    1, 6),
  92   AudioCodec(102, "iLBC",   8000,  13300, 1, 5),
  93   AudioCodec(0,   "PCMU",   8000,  64000, 1, 4),
  94   AudioCodec(8,   "PCMA",   8000,  64000, 1, 3),
  95   AudioCodec(117, "red",    8000,  0,     1, 2),
  96   AudioCodec(107, "CN",     48000, 0,     1, 1)
  97 };
  98
  99 static const AudioCodec kAudioCodecs2[] = {
 100   AudioCodec(126, "speex",  16000, 22000, 1, 3),
 101   AudioCodec(0,   "PCMU",   8000,  64000, 1, 2),
 102   AudioCodec(127, "iLBC",   8000,  13300, 1, 1),
 103 };
 104
 105 static const AudioCodec kAudioCodecsAnswer[] = {
 106   AudioCodec(102, "iLBC",   8000,  13300, 1, 5),
 107   AudioCodec(0,   "PCMU",   8000,  64000, 1, 4),
 108 };
 109
 110 static const VideoCodec kVideoCodecs1[] = {
 111   VideoCodec(96, "H264-SVC", 320, 200, 30, 2),
 112   VideoCodec(97, "H264", 320, 200, 30, 1)
 113 };
 114
 115 static const VideoCodec kVideoCodecs2[] = {
 116   VideoCodec(126, "H264", 320, 200, 30, 2),
 117   VideoCodec(127, "H263", 320, 200, 30, 1)
 118 };
 119
 120 static const VideoCodec kVideoCodecsAnswer[] = {
 121   VideoCodec(97, "H264", 320, 200, 30, 1)
 122 };
 123
 124 static const DataCodec kDataCodecs1[] = {
 125   DataCodec(98, "binary-data", 2),
 126   DataCodec(99, "utf8-text", 1)
 127 };
 128
 129 static const DataCodec kDataCodecs2[] = {
 130   DataCodec(126, "binary-data", 2),
 131   DataCodec(127, "utf8-text", 1)
 132 };
 133
 134 static const DataCodec kDataCodecsAnswer[] = {
 135   DataCodec(98, "binary-data", 2),
 136   DataCodec(99, "utf8-text", 1)
 137 };
 138
 139 static const RtpHeaderExtension kAudioRtpExtension1[] = {
 140   RtpHeaderExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8),
 141   RtpHeaderExtension("http://google.com/testing/audio_something", 10),
 142 };
 143
 144 static const RtpHeaderExtension kAudioRtpExtension2[] = {
 145   RtpHeaderExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 2),
 146   RtpHeaderExtension("http://google.com/testing/audio_something_else", 8),
 147   RtpHeaderExtension("http://google.com/testing/both_audio_and_video", 7),
 148 };
 149
 150 static const RtpHeaderExtension kAudioRtpExtensionAnswer[] = {
 151   RtpHeaderExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8),
 152 };
 153
 154 static const RtpHeaderExtension kVideoRtpExtension1[] = {
 155   RtpHeaderExtension("urn:ietf:params:rtp-hdrext:toffset", 14),
 156   RtpHeaderExtension("http://google.com/testing/video_something", 13),
 157 };
 158
 159 static const RtpHeaderExtension kVideoRtpExtension2[] = {
 160   RtpHeaderExtension("urn:ietf:params:rtp-hdrext:toffset", 2),
 161   RtpHeaderExtension("http://google.com/testing/video_something_else", 14),
 162   RtpHeaderExtension("http://google.com/testing/both_audio_and_video", 7),
 163 };
 164
 165 static const RtpHeaderExtension kVideoRtpExtensionAnswer[] = {
 166   RtpHeaderExtension("urn:ietf:params:rtp-hdrext:toffset", 14),
 167 };
 168
 169 static const uint32 kSimulcastParamsSsrc[] = {10, 11, 20, 21, 30, 31};
 170 static const uint32 kSimSsrc[] = {10, 20, 30};
 171 static const uint32 kFec1Ssrc[] = {10, 11};
 172 static const uint32 kFec2Ssrc[] = {20, 21};
 173 static const uint32 kFec3Ssrc[] = {30, 31};
 174
 175 static const char kMediaStream1[] = "stream_1";
 176 static const char kMediaStream2[] = "stream_2";
 177 static const char kVideoTrack1[] = "video_1";
 178 static const char kVideoTrack2[] = "video_2";
 179 static const char kAudioTrack1[] = "audio_1";
 180 static const char kAudioTrack2[] = "audio_2";
 181 static const char kAudioTrack3[] = "audio_3";
 182 static const char kDataTrack1[] = "data_1";
 183 static const char kDataTrack2[] = "data_2";
 184 static const char kDataTrack3[] = "data_3";
 185
 186 static bool IsMediaContentOfType(const ContentInfo* content,
 187                                  MediaType media_type) {
 188   const MediaContentDescription* mdesc =
 189       static_cast<const MediaContentDescription*>(content->description);
 190   return mdesc && mdesc->type() == media_type;
 191 }
 192
 193 class MediaSessionDescriptionFactoryTest : public testing::Test {
 194  public:
 195   MediaSessionDescriptionFactoryTest()
 196       : f1_(&tdf1_), f2_(&tdf2_), id1_("id1"), id2_("id2") {
 197     f1_.set_audio_codecs(MAKE_VECTOR(kAudioCodecs1));
 198     f1_.set_video_codecs(MAKE_VECTOR(kVideoCodecs1));
 199     f1_.set_data_codecs(MAKE_VECTOR(kDataCodecs1));
 200     f2_.set_audio_codecs(MAKE_VECTOR(kAudioCodecs2));
 201     f2_.set_video_codecs(MAKE_VECTOR(kVideoCodecs2));
 202     f2_.set_data_codecs(MAKE_VECTOR(kDataCodecs2));
 203     tdf1_.set_identity(&id1_);
 204     tdf2_.set_identity(&id2_);
 205   }
 206
 207   static void SetUpTestCase() {
 208     rtc::InitializeSSL();
 209   }
 210
 211   static void TearDownTestCase() {
 212     rtc::CleanupSSL();
 213   }
 214
 215   // Create a video StreamParamsVec object with:
 216   // - one video stream with 3 simulcast streams and FEC,
 217   StreamParamsVec CreateComplexVideoStreamParamsVec() {
 218     SsrcGroup sim_group("SIM", MAKE_VECTOR(kSimSsrc));
 219     SsrcGroup fec_group1("FEC", MAKE_VECTOR(kFec1Ssrc));
 220     SsrcGroup fec_group2("FEC", MAKE_VECTOR(kFec2Ssrc));
 221     SsrcGroup fec_group3("FEC", MAKE_VECTOR(kFec3Ssrc));
 222
 223     std::vector<SsrcGroup> ssrc_groups;
 224     ssrc_groups.push_back(sim_group);
 225     ssrc_groups.push_back(fec_group1);
 226     ssrc_groups.push_back(fec_group2);
 227     ssrc_groups.push_back(fec_group3);
 228
 229     StreamParams simulcast_params;
 230     simulcast_params.id = kVideoTrack1;
 231     simulcast_params.ssrcs = MAKE_VECTOR(kSimulcastParamsSsrc);
 232     simulcast_params.ssrc_groups = ssrc_groups;
 233     simulcast_params.cname = "Video_SIM_FEC";
 234     simulcast_params.sync_label = kMediaStream1;
 235
 236     StreamParamsVec video_streams;
 237     video_streams.push_back(simulcast_params);
 238
 239     return video_streams;
 240   }
 241
 242   bool CompareCryptoParams(const CryptoParamsVec& c1,
 243                            const CryptoParamsVec& c2) {
 244     if (c1.size() != c2.size())
 245       return false;
 246     for (size_t i = 0; i < c1.size(); ++i)
 247       if (c1[i].tag != c2[i].tag || c1[i].cipher_suite != c2[i].cipher_suite ||
 248           c1[i].key_params != c2[i].key_params ||
 249           c1[i].session_params != c2[i].session_params)
 250         return false;
 251     return true;
 252   }
 253
 254   void TestTransportInfo(bool offer, const MediaSessionOptions& options,
 255                          bool has_current_desc) {
 256     const std::string current_audio_ufrag = "current_audio_ufrag";
 257     const std::string current_audio_pwd = "current_audio_pwd";
 258     const std::string current_video_ufrag = "current_video_ufrag";
 259     const std::string current_video_pwd = "current_video_pwd";
 260     const std::string current_data_ufrag = "current_data_ufrag";
 261     const std::string current_data_pwd = "current_data_pwd";
 262     rtc::scoped_ptr<SessionDescription> current_desc;
 263     rtc::scoped_ptr<SessionDescription> desc;
 264     if (has_current_desc) {
 265       current_desc.reset(new SessionDescription());
 266       EXPECT_TRUE(current_desc->AddTransportInfo(
 267           TransportInfo("audio",
 268                         TransportDescription("",
 269                                              current_audio_ufrag,
 270                                              current_audio_pwd))));
 271       EXPECT_TRUE(current_desc->AddTransportInfo(
 272           TransportInfo("video",
 273                         TransportDescription("",
 274                                              current_video_ufrag,
 275                                              current_video_pwd))));
 276       EXPECT_TRUE(current_desc->AddTransportInfo(
 277           TransportInfo("data",
 278                         TransportDescription("",
 279                                              current_data_ufrag,
 280                                              current_data_pwd))));
 281     }
 282     if (offer) {
 283       desc.reset(f1_.CreateOffer(options, current_desc.get()));
 284     } else {
 285       rtc::scoped_ptr<SessionDescription> offer;
 286       offer.reset(f1_.CreateOffer(options, NULL));
 287       desc.reset(f1_.CreateAnswer(offer.get(), options, current_desc.get()));
 288     }
 289     ASSERT_TRUE(desc.get() != NULL);
 290     const TransportInfo* ti_audio = desc->GetTransportInfoByName("audio");
 291     if (options.has_audio) {
 292       EXPECT_TRUE(ti_audio != NULL);
 293       if (has_current_desc) {
 294         EXPECT_EQ(current_audio_ufrag, ti_audio->description.ice_ufrag);
 295         EXPECT_EQ(current_audio_pwd, ti_audio->description.ice_pwd);
 296       } else {
 297         EXPECT_EQ(static_cast<size_t>(cricket::ICE_UFRAG_LENGTH),
 298                   ti_audio->description.ice_ufrag.size());
 299         EXPECT_EQ(static_cast<size_t>(cricket::ICE_PWD_LENGTH),
 300                   ti_audio->description.ice_pwd.size());
 301       }
 302
 303     } else {
 304       EXPECT_TRUE(ti_audio == NULL);
 305     }
 306     const TransportInfo* ti_video = desc->GetTransportInfoByName("video");
 307     if (options.has_video) {
 308       EXPECT_TRUE(ti_video != NULL);
 309       if (options.bundle_enabled) {
 310         EXPECT_EQ(ti_audio->description.ice_ufrag,
 311                   ti_video->description.ice_ufrag);
 312         EXPECT_EQ(ti_audio->description.ice_pwd,
 313                   ti_video->description.ice_pwd);
 314       } else {
 315         if (has_current_desc) {
 316           EXPECT_EQ(current_video_ufrag, ti_video->description.ice_ufrag);
 317           EXPECT_EQ(current_video_pwd, ti_video->description.ice_pwd);
 318         } else {
 319           EXPECT_EQ(static_cast<size_t>(cricket::ICE_UFRAG_LENGTH),
 320                     ti_video->description.ice_ufrag.size());
 321           EXPECT_EQ(static_cast<size_t>(cricket::ICE_PWD_LENGTH),
 322                     ti_video->description.ice_pwd.size());
 323         }
 324       }
 325     } else {
 326       EXPECT_TRUE(ti_video == NULL);
 327     }
 328     const TransportInfo* ti_data = desc->GetTransportInfoByName("data");
 329     if (options.has_data()) {
 330       EXPECT_TRUE(ti_data != NULL);
 331       if (options.bundle_enabled) {
 332         EXPECT_EQ(ti_audio->description.ice_ufrag,
 333                   ti_data->description.ice_ufrag);
 334         EXPECT_EQ(ti_audio->description.ice_pwd,
 335                   ti_data->description.ice_pwd);
 336       } else {
 337         if (has_current_desc) {
 338           EXPECT_EQ(current_data_ufrag, ti_data->description.ice_ufrag);
 339           EXPECT_EQ(current_data_pwd, ti_data->description.ice_pwd);
 340         } else {
 341           EXPECT_EQ(static_cast<size_t>(cricket::ICE_UFRAG_LENGTH),
 342                     ti_data->description.ice_ufrag.size());
 343           EXPECT_EQ(static_cast<size_t>(cricket::ICE_PWD_LENGTH),
 344                     ti_data->description.ice_pwd.size());
 345         }
 346       }
 347     } else {
 348       EXPECT_TRUE(ti_video == NULL);
 349     }
 350   }
 351
 352   void TestCryptoWithBundle(bool offer) {
 353     f1_.set_secure(SEC_ENABLED);
 354     MediaSessionOptions options;
 355     options.has_audio = true;
 356     options.has_video = true;
 357     options.data_channel_type = cricket::DCT_RTP;
 358     rtc::scoped_ptr<SessionDescription> ref_desc;
 359     rtc::scoped_ptr<SessionDescription> desc;
 360     if (offer) {
 361       options.bundle_enabled = false;
 362       ref_desc.reset(f1_.CreateOffer(options, NULL));
 363       options.bundle_enabled = true;
 364       desc.reset(f1_.CreateOffer(options, ref_desc.get()));
 365     } else {
 366       options.bundle_enabled = true;
 367       ref_desc.reset(f1_.CreateOffer(options, NULL));
 368       desc.reset(f1_.CreateAnswer(ref_desc.get(), options, NULL));
 369     }
 370     ASSERT_TRUE(desc.get() != NULL);
 371     const cricket::MediaContentDescription* audio_media_desc =
 372         static_cast<const cricket::MediaContentDescription*>(
 373             desc.get()->GetContentDescriptionByName("audio"));
 374     ASSERT_TRUE(audio_media_desc != NULL);
 375     const cricket::MediaContentDescription* video_media_desc =
 376         static_cast<const cricket::MediaContentDescription*>(
 377             desc.get()->GetContentDescriptionByName("video"));
 378     ASSERT_TRUE(video_media_desc != NULL);
 379     EXPECT_TRUE(CompareCryptoParams(audio_media_desc->cryptos(),
 380                                     video_media_desc->cryptos()));
 381     EXPECT_EQ(1u, audio_media_desc->cryptos().size());
 382     EXPECT_EQ(std::string(CS_AES_CM_128_HMAC_SHA1_80),
 383               audio_media_desc->cryptos()[0].cipher_suite);
 384
 385     // Verify the selected crypto is one from the reference audio
 386     // media content.
 387     const cricket::MediaContentDescription* ref_audio_media_desc =
 388         static_cast<const cricket::MediaContentDescription*>(
 389             ref_desc.get()->GetContentDescriptionByName("audio"));
 390     bool found = false;
 391     for (size_t i = 0; i < ref_audio_media_desc->cryptos().size(); ++i) {
 392       if (ref_audio_media_desc->cryptos()[i].Matches(
 393           audio_media_desc->cryptos()[0])) {
 394         found = true;
 395         break;
 396       }
 397     }
 398     EXPECT_TRUE(found);
 399   }
 400
 401   // This test that the audio and video media direction is set to
 402   // |expected_direction_in_answer| in an answer if the offer direction is set
 403   // to |direction_in_offer|.
 404   void TestMediaDirectionInAnswer(
 405       cricket::MediaContentDirection direction_in_offer,
 406       cricket::MediaContentDirection expected_direction_in_answer) {
 407     MediaSessionOptions opts;
 408     opts.has_video = true;
 409     rtc::scoped_ptr<SessionDescription> offer(
 410         f1_.CreateOffer(opts, NULL));
 411     ASSERT_TRUE(offer.get() != NULL);
 412     ContentInfo* ac_offer= offer->GetContentByName("audio");
 413     ASSERT_TRUE(ac_offer != NULL);
 414     AudioContentDescription* acd_offer =
 415         static_cast<AudioContentDescription*>(ac_offer->description);
 416     acd_offer->set_direction(direction_in_offer);
 417     ContentInfo* vc_offer= offer->GetContentByName("video");
 418     ASSERT_TRUE(vc_offer != NULL);
 419     VideoContentDescription* vcd_offer =
 420         static_cast<VideoContentDescription*>(vc_offer->description);
 421     vcd_offer->set_direction(direction_in_offer);
 422
 423     rtc::scoped_ptr<SessionDescription> answer(
 424         f2_.CreateAnswer(offer.get(), opts, NULL));
 425     const AudioContentDescription* acd_answer =
 426         GetFirstAudioContentDescription(answer.get());
 427     EXPECT_EQ(expected_direction_in_answer, acd_answer->direction());
 428     const VideoContentDescription* vcd_answer =
 429         GetFirstVideoContentDescription(answer.get());
 430     EXPECT_EQ(expected_direction_in_answer, vcd_answer->direction());
 431   }
 432
 433   bool VerifyNoCNCodecs(const cricket::ContentInfo* content) {
 434     const cricket::ContentDescription* description = content->description;
 435     ASSERT(description != NULL);
 436     const cricket::AudioContentDescription* audio_content_desc =
 437         static_cast<const cricket::AudioContentDescription*>(description);
 438     ASSERT(audio_content_desc != NULL);
 439     for (size_t i = 0; i < audio_content_desc->codecs().size(); ++i) {
 440       if (audio_content_desc->codecs()[i].name == "CN")
 441         return false;
 442     }
 443     return true;
 444   }
 445
 446  protected:
 447   MediaSessionDescriptionFactory f1_;
 448   MediaSessionDescriptionFactory f2_;
 449   TransportDescriptionFactory tdf1_;
 450   TransportDescriptionFactory tdf2_;
 451   rtc::FakeSSLIdentity id1_;
 452   rtc::FakeSSLIdentity id2_;
 453 };
 454
 455 // Create a typical audio offer, and ensure it matches what we expect.
 456 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioOffer) {
 457   f1_.set_secure(SEC_ENABLED);
 458   rtc::scoped_ptr<SessionDescription> offer(
 459       f1_.CreateOffer(MediaSessionOptions(), NULL));
 460   ASSERT_TRUE(offer.get() != NULL);
 461   const ContentInfo* ac = offer->GetContentByName("audio");
 462   const ContentInfo* vc = offer->GetContentByName("video");
 463   ASSERT_TRUE(ac != NULL);
 464   ASSERT_TRUE(vc == NULL);
 465   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
 466   const AudioContentDescription* acd =
 467       static_cast<const AudioContentDescription*>(ac->description);
 468   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
 469   EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
 470   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
 471   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
 472   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
 473   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
 474   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
 475 }
 476
 477 // Create a typical video offer, and ensure it matches what we expect.
 478 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoOffer) {
 479   MediaSessionOptions opts;
 480   opts.has_video = true;
 481   f1_.set_secure(SEC_ENABLED);
 482   rtc::scoped_ptr<SessionDescription>
 483       offer(f1_.CreateOffer(opts, NULL));
 484   ASSERT_TRUE(offer.get() != NULL);
 485   const ContentInfo* ac = offer->GetContentByName("audio");
 486   const ContentInfo* vc = offer->GetContentByName("video");
 487   ASSERT_TRUE(ac != NULL);
 488   ASSERT_TRUE(vc != NULL);
 489   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
 490   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
 491   const AudioContentDescription* acd =
 492       static_cast<const AudioContentDescription*>(ac->description);
 493   const VideoContentDescription* vcd =
 494       static_cast<const VideoContentDescription*>(vc->description);
 495   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
 496   EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
 497   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
 498   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
 499   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
 500   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
 501   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
 502   EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
 503   EXPECT_EQ(f1_.video_codecs(), vcd->codecs());
 504   EXPECT_NE(0U, vcd->first_ssrc());             // a random nonzero ssrc
 505   EXPECT_EQ(kAutoBandwidth, vcd->bandwidth());  // default bandwidth (auto)
 506   EXPECT_TRUE(vcd->rtcp_mux());                 // rtcp-mux defaults on
 507   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
 508   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
 509 }
 510
 511 // Test creating an offer with bundle where the Codecs have the same dynamic
 512 // RTP playlod type. The test verifies that the offer don't contain the
 513 // duplicate RTP payload types.
 514 TEST_F(MediaSessionDescriptionFactoryTest, TestBundleOfferWithSameCodecPlType) {
 515   const VideoCodec& offered_video_codec = f2_.video_codecs()[0];
 516   const AudioCodec& offered_audio_codec = f2_.audio_codecs()[0];
 517   const DataCodec& offered_data_codec = f2_.data_codecs()[0];
 518   ASSERT_EQ(offered_video_codec.id, offered_audio_codec.id);
 519   ASSERT_EQ(offered_video_codec.id, offered_data_codec.id);
 520
 521   MediaSessionOptions opts;
 522   opts.has_audio = true;
 523   opts.has_video = true;
 524   opts.data_channel_type = cricket::DCT_RTP;
 525   opts.bundle_enabled = true;
 526   rtc::scoped_ptr<SessionDescription>
 527   offer(f2_.CreateOffer(opts, NULL));
 528   const VideoContentDescription* vcd =
 529       GetFirstVideoContentDescription(offer.get());
 530   const AudioContentDescription* acd =
 531       GetFirstAudioContentDescription(offer.get());
 532   const DataContentDescription* dcd =
 533       GetFirstDataContentDescription(offer.get());
 534   ASSERT_TRUE(NULL != vcd);
 535   ASSERT_TRUE(NULL != acd);
 536   ASSERT_TRUE(NULL != dcd);
 537   EXPECT_NE(vcd->codecs()[0].id, acd->codecs()[0].id);
 538   EXPECT_NE(vcd->codecs()[0].id, dcd->codecs()[0].id);
 539   EXPECT_NE(acd->codecs()[0].id, dcd->codecs()[0].id);
 540   EXPECT_EQ(vcd->codecs()[0].name, offered_video_codec.name);
 541   EXPECT_EQ(acd->codecs()[0].name, offered_audio_codec.name);
 542   EXPECT_EQ(dcd->codecs()[0].name, offered_data_codec.name);
 543 }
 544
 545 // Test creating an updated offer with with bundle, audio, video and data
 546 // after an audio only session has been negotiated.
 547 TEST_F(MediaSessionDescriptionFactoryTest,
 548        TestCreateUpdatedVideoOfferWithBundle) {
 549   f1_.set_secure(SEC_ENABLED);
 550   f2_.set_secure(SEC_ENABLED);
 551   MediaSessionOptions opts;
 552   opts.has_audio = true;
 553   opts.has_video = false;
 554   opts.data_channel_type = cricket::DCT_NONE;
 555   opts.bundle_enabled = true;
 556   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
 557   rtc::scoped_ptr<SessionDescription> answer(
 558       f2_.CreateAnswer(offer.get(), opts, NULL));
 559
 560   MediaSessionOptions updated_opts;
 561   updated_opts.has_audio = true;
 562   updated_opts.has_video = true;
 563   updated_opts.data_channel_type = cricket::DCT_RTP;
 564   updated_opts.bundle_enabled = true;
 565   rtc::scoped_ptr<SessionDescription> updated_offer(f1_.CreateOffer(
 566       updated_opts, answer.get()));
 567
 568   const AudioContentDescription* acd =
 569       GetFirstAudioContentDescription(updated_offer.get());
 570   const VideoContentDescription* vcd =
 571       GetFirstVideoContentDescription(updated_offer.get());
 572   const DataContentDescription* dcd =
 573       GetFirstDataContentDescription(updated_offer.get());
 574   EXPECT_TRUE(NULL != vcd);
 575   EXPECT_TRUE(NULL != acd);
 576   EXPECT_TRUE(NULL != dcd);
 577
 578   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
 579   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
 580   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
 581   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
 582   ASSERT_CRYPTO(dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
 583   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), dcd->protocol());
 584 }
 585 // Create a RTP data offer, and ensure it matches what we expect.
 586 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateRtpDataOffer) {
 587   MediaSessionOptions opts;
 588   opts.data_channel_type = cricket::DCT_RTP;
 589   f1_.set_secure(SEC_ENABLED);
 590   rtc::scoped_ptr<SessionDescription>
 591       offer(f1_.CreateOffer(opts, NULL));
 592   ASSERT_TRUE(offer.get() != NULL);
 593   const ContentInfo* ac = offer->GetContentByName("audio");
 594   const ContentInfo* dc = offer->GetContentByName("data");
 595   ASSERT_TRUE(ac != NULL);
 596   ASSERT_TRUE(dc != NULL);
 597   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
 598   EXPECT_EQ(std::string(NS_JINGLE_RTP), dc->type);
 599   const AudioContentDescription* acd =
 600       static_cast<const AudioContentDescription*>(ac->description);
 601   const DataContentDescription* dcd =
 602       static_cast<const DataContentDescription*>(dc->description);
 603   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
 604   EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
 605   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
 606   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
 607   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
 608   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
 609   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
 610   EXPECT_EQ(MEDIA_TYPE_DATA, dcd->type());
 611   EXPECT_EQ(f1_.data_codecs(), dcd->codecs());
 612   EXPECT_NE(0U, dcd->first_ssrc());             // a random nonzero ssrc
 613   EXPECT_EQ(cricket::kDataMaxBandwidth,
 614             dcd->bandwidth());                  // default bandwidth (auto)
 615   EXPECT_TRUE(dcd->rtcp_mux());                 // rtcp-mux defaults on
 616   ASSERT_CRYPTO(dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
 617   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), dcd->protocol());
 618 }
 619
 620 // Create an SCTP data offer with bundle without error.
 621 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSctpDataOffer) {
 622   MediaSessionOptions opts;
 623   opts.has_audio = false;
 624   opts.bundle_enabled = true;
 625   opts.data_channel_type = cricket::DCT_SCTP;
 626   f1_.set_secure(SEC_ENABLED);
 627   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
 628   EXPECT_TRUE(offer.get() != NULL);
 629   EXPECT_TRUE(offer->GetContentByName("data") != NULL);
 630 }
 631
 632 // Create an audio, video offer without legacy StreamParams.
 633 TEST_F(MediaSessionDescriptionFactoryTest,
 634        TestCreateOfferWithoutLegacyStreams) {
 635   MediaSessionOptions opts;
 636   opts.has_video = true;
 637   f1_.set_add_legacy_streams(false);
 638   rtc::scoped_ptr<SessionDescription>
 639       offer(f1_.CreateOffer(opts, NULL));
 640   ASSERT_TRUE(offer.get() != NULL);
 641   const ContentInfo* ac = offer->GetContentByName("audio");
 642   const ContentInfo* vc = offer->GetContentByName("video");
 643   ASSERT_TRUE(ac != NULL);
 644   ASSERT_TRUE(vc != NULL);
 645   const AudioContentDescription* acd =
 646       static_cast<const AudioContentDescription*>(ac->description);
 647   const VideoContentDescription* vcd =
 648       static_cast<const VideoContentDescription*>(vc->description);
 649
 650   EXPECT_FALSE(vcd->has_ssrcs());             // No StreamParams.
 651   EXPECT_FALSE(acd->has_ssrcs());             // No StreamParams.
 652 }
 653
 654 // Verifies that the order of the media contents in the current
 655 // SessionDescription is preserved in the new SessionDescription.
 656 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateOfferContentOrder) {
 657   MediaSessionOptions opts;
 658   opts.has_audio = false;
 659   opts.has_video = false;
 660   opts.data_channel_type = cricket::DCT_SCTP;
 661
 662   rtc::scoped_ptr<SessionDescription> offer1(f1_.CreateOffer(opts, NULL));
 663   ASSERT_TRUE(offer1.get() != NULL);
 664   EXPECT_EQ(1u, offer1->contents().size());
 665   EXPECT_TRUE(IsMediaContentOfType(&offer1->contents()[0], MEDIA_TYPE_DATA));
 666
 667   opts.has_video = true;
 668   rtc::scoped_ptr<SessionDescription> offer2(
 669       f1_.CreateOffer(opts, offer1.get()));
 670   ASSERT_TRUE(offer2.get() != NULL);
 671   EXPECT_EQ(2u, offer2->contents().size());
 672   EXPECT_TRUE(IsMediaContentOfType(&offer2->contents()[0], MEDIA_TYPE_DATA));
 673   EXPECT_TRUE(IsMediaContentOfType(&offer2->contents()[1], MEDIA_TYPE_VIDEO));
 674
 675   opts.has_audio = true;
 676   rtc::scoped_ptr<SessionDescription> offer3(
 677       f1_.CreateOffer(opts, offer2.get()));
 678   ASSERT_TRUE(offer3.get() != NULL);
 679   EXPECT_EQ(3u, offer3->contents().size());
 680   EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[0], MEDIA_TYPE_DATA));
 681   EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[1], MEDIA_TYPE_VIDEO));
 682   EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[2], MEDIA_TYPE_AUDIO));
 683
 684   // Verifies the default order is audio-video-data, so that the previous checks
 685   // didn't pass by accident.
 686   rtc::scoped_ptr<SessionDescription> offer4(f1_.CreateOffer(opts, NULL));
 687   ASSERT_TRUE(offer4.get() != NULL);
 688   EXPECT_EQ(3u, offer4->contents().size());
 689   EXPECT_TRUE(IsMediaContentOfType(&offer4->contents()[0], MEDIA_TYPE_AUDIO));
 690   EXPECT_TRUE(IsMediaContentOfType(&offer4->contents()[1], MEDIA_TYPE_VIDEO));
 691   EXPECT_TRUE(IsMediaContentOfType(&offer4->contents()[2], MEDIA_TYPE_DATA));
 692 }
 693
 694 // Create a typical audio answer, and ensure it matches what we expect.
 695 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswer) {
 696   f1_.set_secure(SEC_ENABLED);
 697   f2_.set_secure(SEC_ENABLED);
 698   rtc::scoped_ptr<SessionDescription> offer(
 699       f1_.CreateOffer(MediaSessionOptions(), NULL));
 700   ASSERT_TRUE(offer.get() != NULL);
 701   rtc::scoped_ptr<SessionDescription> answer(
 702       f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
 703   const ContentInfo* ac = answer->GetContentByName("audio");
 704   const ContentInfo* vc = answer->GetContentByName("video");
 705   ASSERT_TRUE(ac != NULL);
 706   ASSERT_TRUE(vc == NULL);
 707   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
 708   const AudioContentDescription* acd =
 709       static_cast<const AudioContentDescription*>(ac->description);
 710   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
 711   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
 712   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
 713   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
 714   EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
 715   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
 716   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
 717 }
 718
 719 // Create a typical video answer, and ensure it matches what we expect.
 720 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswer) {
 721   MediaSessionOptions opts;
 722   opts.has_video = true;
 723   f1_.set_secure(SEC_ENABLED);
 724   f2_.set_secure(SEC_ENABLED);
 725   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
 726   ASSERT_TRUE(offer.get() != NULL);
 727   rtc::scoped_ptr<SessionDescription> answer(
 728       f2_.CreateAnswer(offer.get(), opts, NULL));
 729   const ContentInfo* ac = answer->GetContentByName("audio");
 730   const ContentInfo* vc = answer->GetContentByName("video");
 731   ASSERT_TRUE(ac != NULL);
 732   ASSERT_TRUE(vc != NULL);
 733   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
 734   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
 735   const AudioContentDescription* acd =
 736       static_cast<const AudioContentDescription*>(ac->description);
 737   const VideoContentDescription* vcd =
 738       static_cast<const VideoContentDescription*>(vc->description);
 739   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
 740   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
 741   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
 742   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
 743   EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
 744   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
 745   EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
 746   EXPECT_EQ(MAKE_VECTOR(kVideoCodecsAnswer), vcd->codecs());
 747   EXPECT_NE(0U, vcd->first_ssrc());             // a random nonzero ssrc
 748   EXPECT_TRUE(vcd->rtcp_mux());                 // negotiated rtcp-mux
 749   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
 750   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
 751 }
 752
 753 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateDataAnswer) {
 754   MediaSessionOptions opts;
 755   opts.data_channel_type = cricket::DCT_RTP;
 756   f1_.set_secure(SEC_ENABLED);
 757   f2_.set_secure(SEC_ENABLED);
 758   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
 759   ASSERT_TRUE(offer.get() != NULL);
 760   rtc::scoped_ptr<SessionDescription> answer(
 761       f2_.CreateAnswer(offer.get(), opts, NULL));
 762   const ContentInfo* ac = answer->GetContentByName("audio");
 763   const ContentInfo* vc = answer->GetContentByName("data");
 764   ASSERT_TRUE(ac != NULL);
 765   ASSERT_TRUE(vc != NULL);
 766   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
 767   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
 768   const AudioContentDescription* acd =
 769       static_cast<const AudioContentDescription*>(ac->description);
 770   const DataContentDescription* vcd =
 771       static_cast<const DataContentDescription*>(vc->description);
 772   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
 773   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
 774   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
 775   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
 776   EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
 777   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
 778   EXPECT_EQ(MEDIA_TYPE_DATA, vcd->type());
 779   EXPECT_EQ(MAKE_VECTOR(kDataCodecsAnswer), vcd->codecs());
 780   EXPECT_NE(0U, vcd->first_ssrc());             // a random nonzero ssrc
 781   EXPECT_TRUE(vcd->rtcp_mux());                 // negotiated rtcp-mux
 782   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
 783   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
 784 }
 785
 786 // Verifies that the order of the media contents in the offer is preserved in
 787 // the answer.
 788 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAnswerContentOrder) {
 789   MediaSessionOptions opts;
 790
 791   // Creates a data only offer.
 792   opts.has_audio = false;
 793   opts.data_channel_type = cricket::DCT_SCTP;
 794   rtc::scoped_ptr<SessionDescription> offer1(f1_.CreateOffer(opts, NULL));
 795   ASSERT_TRUE(offer1.get() != NULL);
 796
 797   // Appends audio to the offer.
 798   opts.has_audio = true;
 799   rtc::scoped_ptr<SessionDescription> offer2(
 800       f1_.CreateOffer(opts, offer1.get()));
 801   ASSERT_TRUE(offer2.get() != NULL);
 802
 803   // Appends video to the offer.
 804   opts.has_video = true;
 805   rtc::scoped_ptr<SessionDescription> offer3(
 806       f1_.CreateOffer(opts, offer2.get()));
 807   ASSERT_TRUE(offer3.get() != NULL);
 808
 809   rtc::scoped_ptr<SessionDescription> answer(
 810       f2_.CreateAnswer(offer3.get(), opts, NULL));
 811   ASSERT_TRUE(answer.get() != NULL);
 812   EXPECT_EQ(3u, answer->contents().size());
 813   EXPECT_TRUE(IsMediaContentOfType(&answer->contents()[0], MEDIA_TYPE_DATA));
 814   EXPECT_TRUE(IsMediaContentOfType(&answer->contents()[1], MEDIA_TYPE_AUDIO));
 815   EXPECT_TRUE(IsMediaContentOfType(&answer->contents()[2], MEDIA_TYPE_VIDEO));
 816 }
 817
 818 // This test that the media direction is set to send/receive in an answer if
 819 // the offer is send receive.
 820 TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerToSendReceiveOffer) {
 821   TestMediaDirectionInAnswer(cricket::MD_SENDRECV, cricket::MD_SENDRECV);
 822 }
 823
 824 // This test that the media direction is set to receive only in an answer if
 825 // the offer is send only.
 826 TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerToSendOnlyOffer) {
 827   TestMediaDirectionInAnswer(cricket::MD_SENDONLY, cricket::MD_RECVONLY);
 828 }
 829
 830 // This test that the media direction is set to send only in an answer if
 831 // the offer is recv only.
 832 TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerToRecvOnlyOffer) {
 833   TestMediaDirectionInAnswer(cricket::MD_RECVONLY, cricket::MD_SENDONLY);
 834 }
 835
 836 // This test that the media direction is set to inactive in an answer if
 837 // the offer is inactive.
 838 TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerToInactiveOffer) {
 839   TestMediaDirectionInAnswer(cricket::MD_INACTIVE, cricket::MD_INACTIVE);
 840 }
 841
 842 // Test that a data content with an unknown protocol is rejected in an answer.
 843 TEST_F(MediaSessionDescriptionFactoryTest,
 844        CreateDataAnswerToOfferWithUnknownProtocol) {
 845   MediaSessionOptions opts;
 846   opts.data_channel_type = cricket::DCT_RTP;
 847   opts.has_audio = false;
 848   f1_.set_secure(SEC_ENABLED);
 849   f2_.set_secure(SEC_ENABLED);
 850   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
 851   ContentInfo* dc_offer= offer->GetContentByName("data");
 852   ASSERT_TRUE(dc_offer != NULL);
 853   DataContentDescription* dcd_offer =
 854       static_cast<DataContentDescription*>(dc_offer->description);
 855   ASSERT_TRUE(dcd_offer != NULL);
 856   std::string protocol = "a weird unknown protocol";
 857   dcd_offer->set_protocol(protocol);
 858
 859   rtc::scoped_ptr<SessionDescription> answer(
 860       f2_.CreateAnswer(offer.get(), opts, NULL));
 861
 862   const ContentInfo* dc_answer = answer->GetContentByName("data");
 863   ASSERT_TRUE(dc_answer != NULL);
 864   EXPECT_TRUE(dc_answer->rejected);
 865   const DataContentDescription* dcd_answer =
 866       static_cast<const DataContentDescription*>(dc_answer->description);
 867   ASSERT_TRUE(dcd_answer != NULL);
 868   EXPECT_EQ(protocol, dcd_answer->protocol());
 869 }
 870
 871 // Test that the media protocol is RTP/AVPF if DTLS and SDES are disabled.
 872 TEST_F(MediaSessionDescriptionFactoryTest, AudioOfferAnswerWithCryptoDisabled) {
 873   MediaSessionOptions opts;
 874   f1_.set_secure(SEC_DISABLED);
 875   f2_.set_secure(SEC_DISABLED);
 876   tdf1_.set_secure(SEC_DISABLED);
 877   tdf2_.set_secure(SEC_DISABLED);
 878
 879   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
 880   const AudioContentDescription* offer_acd =
 881       GetFirstAudioContentDescription(offer.get());
 882   ASSERT_TRUE(offer_acd != NULL);
 883   EXPECT_EQ(std::string(cricket::kMediaProtocolAvpf), offer_acd->protocol());
 884
 885   rtc::scoped_ptr<SessionDescription> answer(
 886       f2_.CreateAnswer(offer.get(), opts, NULL));
 887
 888   const ContentInfo* ac_answer = answer->GetContentByName("audio");
 889   ASSERT_TRUE(ac_answer != NULL);
 890   EXPECT_FALSE(ac_answer->rejected);
 891
 892   const AudioContentDescription* answer_acd =
 893       GetFirstAudioContentDescription(answer.get());
 894   ASSERT_TRUE(answer_acd != NULL);
 895   EXPECT_EQ(std::string(cricket::kMediaProtocolAvpf), answer_acd->protocol());
 896 }
 897
 898 // Create a video offer and answer and ensure the RTP header extensions
 899 // matches what we expect.
 900 TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithRtpExtensions) {
 901   MediaSessionOptions opts;
 902   opts.has_video = true;
 903
 904   f1_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension1));
 905   f1_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension1));
 906   f2_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension2));
 907   f2_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension2));
 908
 909   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
 910   ASSERT_TRUE(offer.get() != NULL);
 911   rtc::scoped_ptr<SessionDescription> answer(
 912       f2_.CreateAnswer(offer.get(), opts, NULL));
 913
 914   EXPECT_EQ(MAKE_VECTOR(kAudioRtpExtension1),
 915             GetFirstAudioContentDescription(
 916                 offer.get())->rtp_header_extensions());
 917   EXPECT_EQ(MAKE_VECTOR(kVideoRtpExtension1),
 918             GetFirstVideoContentDescription(
 919                 offer.get())->rtp_header_extensions());
 920   EXPECT_EQ(MAKE_VECTOR(kAudioRtpExtensionAnswer),
 921             GetFirstAudioContentDescription(
 922                 answer.get())->rtp_header_extensions());
 923   EXPECT_EQ(MAKE_VECTOR(kVideoRtpExtensionAnswer),
 924             GetFirstVideoContentDescription(
 925                 answer.get())->rtp_header_extensions());
 926 }
 927
 928 // Create an audio, video, data answer without legacy StreamParams.
 929 TEST_F(MediaSessionDescriptionFactoryTest,
 930        TestCreateAnswerWithoutLegacyStreams) {
 931   MediaSessionOptions opts;
 932   opts.has_video = true;
 933   opts.data_channel_type = cricket::DCT_RTP;
 934   f1_.set_add_legacy_streams(false);
 935   f2_.set_add_legacy_streams(false);
 936   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
 937   ASSERT_TRUE(offer.get() != NULL);
 938   rtc::scoped_ptr<SessionDescription> answer(
 939       f2_.CreateAnswer(offer.get(), opts, NULL));
 940   const ContentInfo* ac = answer->GetContentByName("audio");
 941   const ContentInfo* vc = answer->GetContentByName("video");
 942   const ContentInfo* dc = answer->GetContentByName("data");
 943   ASSERT_TRUE(ac != NULL);
 944   ASSERT_TRUE(vc != NULL);
 945   const AudioContentDescription* acd =
 946       static_cast<const AudioContentDescription*>(ac->description);
 947   const VideoContentDescription* vcd =
 948       static_cast<const VideoContentDescription*>(vc->description);
 949   const DataContentDescription* dcd =
 950       static_cast<const DataContentDescription*>(dc->description);
 951
 952   EXPECT_FALSE(acd->has_ssrcs());  // No StreamParams.
 953   EXPECT_FALSE(vcd->has_ssrcs());  // No StreamParams.
 954   EXPECT_FALSE(dcd->has_ssrcs());  // No StreamParams.
 955 }
 956
 957 TEST_F(MediaSessionDescriptionFactoryTest, TestPartial) {
 958   MediaSessionOptions opts;
 959   opts.has_video = true;
 960   opts.data_channel_type = cricket::DCT_RTP;
 961   f1_.set_secure(SEC_ENABLED);
 962   rtc::scoped_ptr<SessionDescription>
 963       offer(f1_.CreateOffer(opts, NULL));
 964   ASSERT_TRUE(offer.get() != NULL);
 965   const ContentInfo* ac = offer->GetContentByName("audio");
 966   const ContentInfo* vc = offer->GetContentByName("video");
 967   const ContentInfo* dc = offer->GetContentByName("data");
 968   AudioContentDescription* acd = const_cast<AudioContentDescription*>(
 969       static_cast<const AudioContentDescription*>(ac->description));
 970   VideoContentDescription* vcd = const_cast<VideoContentDescription*>(
 971       static_cast<const VideoContentDescription*>(vc->description));
 972   DataContentDescription* dcd = const_cast<DataContentDescription*>(
 973       static_cast<const DataContentDescription*>(dc->description));
 974
 975   EXPECT_FALSE(acd->partial());  // default is false.
 976   acd->set_partial(true);
 977   EXPECT_TRUE(acd->partial());
 978   acd->set_partial(false);
 979   EXPECT_FALSE(acd->partial());
 980
 981   EXPECT_FALSE(vcd->partial());  // default is false.
 982   vcd->set_partial(true);
 983   EXPECT_TRUE(vcd->partial());
 984   vcd->set_partial(false);
 985   EXPECT_FALSE(vcd->partial());
 986
 987   EXPECT_FALSE(dcd->partial());  // default is false.
 988   dcd->set_partial(true);
 989   EXPECT_TRUE(dcd->partial());
 990   dcd->set_partial(false);
 991   EXPECT_FALSE(dcd->partial());
 992 }
 993
 994 // Create a typical video answer, and ensure it matches what we expect.
 995 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswerRtcpMux) {
 996   MediaSessionOptions offer_opts;
 997   MediaSessionOptions answer_opts;
 998   answer_opts.has_video = true;
 999   offer_opts.has_video = true;
1000   answer_opts.data_channel_type = cricket::DCT_RTP;
1001   offer_opts.data_channel_type = cricket::DCT_RTP;
1002
1003   rtc::scoped_ptr<SessionDescription> offer;
1004   rtc::scoped_ptr<SessionDescription> answer;
1005
1006   offer_opts.rtcp_mux_enabled = true;
1007   answer_opts.rtcp_mux_enabled = true;
1008
1009   offer.reset(f1_.CreateOffer(offer_opts, NULL));
1010   answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
1011   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
1012   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
1013   ASSERT_TRUE(NULL != GetFirstDataContentDescription(offer.get()));
1014   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
1015   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
1016   ASSERT_TRUE(NULL != GetFirstDataContentDescription(answer.get()));
1017   EXPECT_TRUE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
1018   EXPECT_TRUE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
1019   EXPECT_TRUE(GetFirstDataContentDescription(offer.get())->rtcp_mux());
1020   EXPECT_TRUE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
1021   EXPECT_TRUE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
1022   EXPECT_TRUE(GetFirstDataContentDescription(answer.get())->rtcp_mux());
1023
1024   offer_opts.rtcp_mux_enabled = true;
1025   answer_opts.rtcp_mux_enabled = false;
1026
1027   offer.reset(f1_.CreateOffer(offer_opts, NULL));
1028   answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
1029   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
1030   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
1031   ASSERT_TRUE(NULL != GetFirstDataContentDescription(offer.get()));
1032   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
1033   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
1034   ASSERT_TRUE(NULL != GetFirstDataContentDescription(answer.get()));
1035   EXPECT_TRUE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
1036   EXPECT_TRUE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
1037   EXPECT_TRUE(GetFirstDataContentDescription(offer.get())->rtcp_mux());
1038   EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
1039   EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
1040   EXPECT_FALSE(GetFirstDataContentDescription(answer.get())->rtcp_mux());
1041
1042   offer_opts.rtcp_mux_enabled = false;
1043   answer_opts.rtcp_mux_enabled = true;
1044
1045   offer.reset(f1_.CreateOffer(offer_opts, NULL));
1046   answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
1047   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
1048   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
1049   ASSERT_TRUE(NULL != GetFirstDataContentDescription(offer.get()));
1050   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
1051   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
1052   ASSERT_TRUE(NULL != GetFirstDataContentDescription(answer.get()));
1053   EXPECT_FALSE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
1054   EXPECT_FALSE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
1055   EXPECT_FALSE(GetFirstDataContentDescription(offer.get())->rtcp_mux());
1056   EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
1057   EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
1058   EXPECT_FALSE(GetFirstDataContentDescription(answer.get())->rtcp_mux());
1059
1060   offer_opts.rtcp_mux_enabled = false;
1061   answer_opts.rtcp_mux_enabled = false;
1062
1063   offer.reset(f1_.CreateOffer(offer_opts, NULL));
1064   answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
1065   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
1066   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
1067   ASSERT_TRUE(NULL != GetFirstDataContentDescription(offer.get()));
1068   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
1069   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
1070   ASSERT_TRUE(NULL != GetFirstDataContentDescription(answer.get()));
1071   EXPECT_FALSE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
1072   EXPECT_FALSE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
1073   EXPECT_FALSE(GetFirstDataContentDescription(offer.get())->rtcp_mux());
1074   EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
1075   EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
1076   EXPECT_FALSE(GetFirstDataContentDescription(answer.get())->rtcp_mux());
1077 }
1078
1079 // Create an audio-only answer to a video offer.
1080 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswerToVideo) {
1081   MediaSessionOptions opts;
1082   opts.has_video = true;
1083   rtc::scoped_ptr<SessionDescription>
1084       offer(f1_.CreateOffer(opts, NULL));
1085   ASSERT_TRUE(offer.get() != NULL);
1086   rtc::scoped_ptr<SessionDescription> answer(
1087       f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
1088   const ContentInfo* ac = answer->GetContentByName("audio");
1089   const ContentInfo* vc = answer->GetContentByName("video");
1090   ASSERT_TRUE(ac != NULL);
1091   ASSERT_TRUE(vc != NULL);
1092   ASSERT_TRUE(vc->description != NULL);
1093   EXPECT_TRUE(vc->rejected);
1094 }
1095
1096 // Create an audio-only answer to an offer with data.
1097 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateNoDataAnswerToDataOffer) {
1098   MediaSessionOptions opts;
1099   opts.data_channel_type = cricket::DCT_RTP;
1100   rtc::scoped_ptr<SessionDescription>
1101       offer(f1_.CreateOffer(opts, NULL));
1102   ASSERT_TRUE(offer.get() != NULL);
1103   rtc::scoped_ptr<SessionDescription> answer(
1104       f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
1105   const ContentInfo* ac = answer->GetContentByName("audio");
1106   const ContentInfo* dc = answer->GetContentByName("data");
1107   ASSERT_TRUE(ac != NULL);
1108   ASSERT_TRUE(dc != NULL);
1109   ASSERT_TRUE(dc->description != NULL);
1110   EXPECT_TRUE(dc->rejected);
1111 }
1112
1113 // Create an answer that rejects the contents which are rejected in the offer.
1114 TEST_F(MediaSessionDescriptionFactoryTest,
1115        CreateAnswerToOfferWithRejectedMedia) {
1116   MediaSessionOptions opts;
1117   opts.has_video = true;
1118   opts.data_channel_type = cricket::DCT_RTP;
1119   rtc::scoped_ptr<SessionDescription>
1120       offer(f1_.CreateOffer(opts, NULL));
1121   ASSERT_TRUE(offer.get() != NULL);
1122   ContentInfo* ac = offer->GetContentByName("audio");
1123   ContentInfo* vc = offer->GetContentByName("video");
1124   ContentInfo* dc = offer->GetContentByName("data");
1125   ASSERT_TRUE(ac != NULL);
1126   ASSERT_TRUE(vc != NULL);
1127   ASSERT_TRUE(dc != NULL);
1128   ac->rejected = true;
1129   vc->rejected = true;
1130   dc->rejected = true;
1131   rtc::scoped_ptr<SessionDescription> answer(
1132       f2_.CreateAnswer(offer.get(), opts, NULL));
1133   ac = answer->GetContentByName("audio");
1134   vc = answer->GetContentByName("video");
1135   dc = answer->GetContentByName("data");
1136   ASSERT_TRUE(ac != NULL);
1137   ASSERT_TRUE(vc != NULL);
1138   ASSERT_TRUE(dc != NULL);
1139   EXPECT_TRUE(ac->rejected);
1140   EXPECT_TRUE(vc->rejected);
1141   EXPECT_TRUE(dc->rejected);
1142 }
1143
1144 // Create an audio and video offer with:
1145 // - one video track
1146 // - two audio tracks
1147 // - two data tracks
1148 // and ensure it matches what we expect. Also updates the initial offer by
1149 // adding a new video track and replaces one of the audio tracks.
1150 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoOffer) {
1151   MediaSessionOptions opts;
1152   opts.AddStream(MEDIA_TYPE_VIDEO, kVideoTrack1, kMediaStream1);
1153   opts.AddStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
1154   opts.AddStream(MEDIA_TYPE_AUDIO, kAudioTrack2, kMediaStream1);
1155   opts.data_channel_type = cricket::DCT_RTP;
1156   opts.AddStream(MEDIA_TYPE_DATA, kDataTrack1, kMediaStream1);
1157   opts.AddStream(MEDIA_TYPE_DATA, kDataTrack2, kMediaStream1);
1158
1159   f1_.set_secure(SEC_ENABLED);
1160   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
1161
1162   ASSERT_TRUE(offer.get() != NULL);
1163   const ContentInfo* ac = offer->GetContentByName("audio");
1164   const ContentInfo* vc = offer->GetContentByName("video");
1165   const ContentInfo* dc = offer->GetContentByName("data");
1166   ASSERT_TRUE(ac != NULL);
1167   ASSERT_TRUE(vc != NULL);
1168   ASSERT_TRUE(dc != NULL);
1169   const AudioContentDescription* acd =
1170       static_cast<const AudioContentDescription*>(ac->description);
1171   const VideoContentDescription* vcd =
1172       static_cast<const VideoContentDescription*>(vc->description);
1173   const DataContentDescription* dcd =
1174       static_cast<const DataContentDescription*>(dc->description);
1175   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
1176   EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
1177
1178   const StreamParamsVec& audio_streams = acd->streams();
1179   ASSERT_EQ(2U, audio_streams.size());
1180   EXPECT_EQ(audio_streams[0].cname , audio_streams[1].cname);
1181   EXPECT_EQ(kAudioTrack1, audio_streams[0].id);
1182   ASSERT_EQ(1U, audio_streams[0].ssrcs.size());
1183   EXPECT_NE(0U, audio_streams[0].ssrcs[0]);
1184   EXPECT_EQ(kAudioTrack2, audio_streams[1].id);
1185   ASSERT_EQ(1U, audio_streams[1].ssrcs.size());
1186   EXPECT_NE(0U, audio_streams[1].ssrcs[0]);
1187
1188   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
1189   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
1190   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
1191
1192   EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
1193   EXPECT_EQ(f1_.video_codecs(), vcd->codecs());
1194   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
1195
1196   const StreamParamsVec& video_streams = vcd->streams();
1197   ASSERT_EQ(1U, video_streams.size());
1198   EXPECT_EQ(video_streams[0].cname, audio_streams[0].cname);
1199   EXPECT_EQ(kVideoTrack1, video_streams[0].id);
1200   EXPECT_EQ(kAutoBandwidth, vcd->bandwidth());  // default bandwidth (auto)
1201   EXPECT_TRUE(vcd->rtcp_mux());                 // rtcp-mux defaults on
1202
1203   EXPECT_EQ(MEDIA_TYPE_DATA, dcd->type());
1204   EXPECT_EQ(f1_.data_codecs(), dcd->codecs());
1205   ASSERT_CRYPTO(dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
1206
1207   const StreamParamsVec& data_streams = dcd->streams();
1208   ASSERT_EQ(2U, data_streams.size());
1209   EXPECT_EQ(data_streams[0].cname , data_streams[1].cname);
1210   EXPECT_EQ(kDataTrack1, data_streams[0].id);
1211   ASSERT_EQ(1U, data_streams[0].ssrcs.size());
1212   EXPECT_NE(0U, data_streams[0].ssrcs[0]);
1213   EXPECT_EQ(kDataTrack2, data_streams[1].id);
1214   ASSERT_EQ(1U, data_streams[1].ssrcs.size());
1215   EXPECT_NE(0U, data_streams[1].ssrcs[0]);
1216
1217   EXPECT_EQ(cricket::kDataMaxBandwidth,
1218             dcd->bandwidth());                  // default bandwidth (auto)
1219   EXPECT_TRUE(dcd->rtcp_mux());                 // rtcp-mux defaults on
1220   ASSERT_CRYPTO(dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
1221
1222
1223   // Update the offer. Add a new video track that is not synched to the
1224   // other tracks and replace audio track 2 with audio track 3.
1225   opts.AddStream(MEDIA_TYPE_VIDEO, kVideoTrack2, kMediaStream2);
1226   opts.RemoveStream(MEDIA_TYPE_AUDIO, kAudioTrack2);
1227   opts.AddStream(MEDIA_TYPE_AUDIO, kAudioTrack3, kMediaStream1);
1228   opts.RemoveStream(MEDIA_TYPE_DATA, kDataTrack2);
1229   opts.AddStream(MEDIA_TYPE_DATA, kDataTrack3, kMediaStream1);
1230   rtc::scoped_ptr<SessionDescription>
1231       updated_offer(f1_.CreateOffer(opts, offer.get()));
1232
1233   ASSERT_TRUE(updated_offer.get() != NULL);
1234   ac = updated_offer->GetContentByName("audio");
1235   vc = updated_offer->GetContentByName("video");
1236   dc = updated_offer->GetContentByName("data");
1237   ASSERT_TRUE(ac != NULL);
1238   ASSERT_TRUE(vc != NULL);
1239   ASSERT_TRUE(dc != NULL);
1240   const AudioContentDescription* updated_acd =
1241       static_cast<const AudioContentDescription*>(ac->description);
1242   const VideoContentDescription* updated_vcd =
1243       static_cast<const VideoContentDescription*>(vc->description);
1244   const DataContentDescription* updated_dcd =
1245       static_cast<const DataContentDescription*>(dc->description);
1246
1247   EXPECT_EQ(acd->type(), updated_acd->type());
1248   EXPECT_EQ(acd->codecs(), updated_acd->codecs());
1249   EXPECT_EQ(vcd->type(), updated_vcd->type());
1250   EXPECT_EQ(vcd->codecs(), updated_vcd->codecs());
1251   EXPECT_EQ(dcd->type(), updated_dcd->type());
1252   EXPECT_EQ(dcd->codecs(), updated_dcd->codecs());
1253   ASSERT_CRYPTO(updated_acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
1254   EXPECT_TRUE(CompareCryptoParams(acd->cryptos(), updated_acd->cryptos()));
1255   ASSERT_CRYPTO(updated_vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
1256   EXPECT_TRUE(CompareCryptoParams(vcd->cryptos(), updated_vcd->cryptos()));
1257   ASSERT_CRYPTO(updated_dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
1258   EXPECT_TRUE(CompareCryptoParams(dcd->cryptos(), updated_dcd->cryptos()));
1259
1260   const StreamParamsVec& updated_audio_streams = updated_acd->streams();
1261   ASSERT_EQ(2U, updated_audio_streams.size());
1262   EXPECT_EQ(audio_streams[0], updated_audio_streams[0]);
1263   EXPECT_EQ(kAudioTrack3, updated_audio_streams[1].id);  // New audio track.
1264   ASSERT_EQ(1U, updated_audio_streams[1].ssrcs.size());
1265   EXPECT_NE(0U, updated_audio_streams[1].ssrcs[0]);
1266   EXPECT_EQ(updated_audio_streams[0].cname, updated_audio_streams[1].cname);
1267
1268   const StreamParamsVec& updated_video_streams = updated_vcd->streams();
1269   ASSERT_EQ(2U, updated_video_streams.size());
1270   EXPECT_EQ(video_streams[0], updated_video_streams[0]);
1271   EXPECT_EQ(kVideoTrack2, updated_video_streams[1].id);
1272   EXPECT_NE(updated_video_streams[1].cname, updated_video_streams[0].cname);
1273
1274   const StreamParamsVec& updated_data_streams = updated_dcd->streams();
1275   ASSERT_EQ(2U, updated_data_streams.size());
1276   EXPECT_EQ(data_streams[0], updated_data_streams[0]);
1277   EXPECT_EQ(kDataTrack3, updated_data_streams[1].id);  // New data track.
1278   ASSERT_EQ(1U, updated_data_streams[1].ssrcs.size());
1279   EXPECT_NE(0U, updated_data_streams[1].ssrcs[0]);
1280   EXPECT_EQ(updated_data_streams[0].cname, updated_data_streams[1].cname);
1281 }
1282
1283 // Create an offer with simulcast video stream.
1284 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSimulcastVideoOffer) {
1285   MediaSessionOptions opts;
1286   const int num_sim_layers = 3;
1287   opts.AddVideoStream(kVideoTrack1, kMediaStream1, num_sim_layers);
1288   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
1289
1290   ASSERT_TRUE(offer.get() != NULL);
1291   const ContentInfo* vc = offer->GetContentByName("video");
1292   ASSERT_TRUE(vc != NULL);
1293   const VideoContentDescription* vcd =
1294       static_cast<const VideoContentDescription*>(vc->description);
1295
1296   const StreamParamsVec& video_streams = vcd->streams();
1297   ASSERT_EQ(1U, video_streams.size());
1298   EXPECT_EQ(kVideoTrack1, video_streams[0].id);
1299   const SsrcGroup* sim_ssrc_group =
1300       video_streams[0].get_ssrc_group(cricket::kSimSsrcGroupSemantics);
1301   ASSERT_TRUE(sim_ssrc_group != NULL);
1302   EXPECT_EQ(static_cast<size_t>(num_sim_layers), sim_ssrc_group->ssrcs.size());
1303 }
1304
1305 // Create an audio and video answer to a standard video offer with:
1306 // - one video track
1307 // - two audio tracks
1308 // - two data tracks
1309 // and ensure it matches what we expect. Also updates the initial answer by
1310 // adding a new video track and removes one of the audio tracks.
1311 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoAnswer) {
1312   MediaSessionOptions offer_opts;
1313   offer_opts.has_video = true;
1314   offer_opts.data_channel_type = cricket::DCT_RTP;
1315   f1_.set_secure(SEC_ENABLED);
1316   f2_.set_secure(SEC_ENABLED);
1317   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(offer_opts,
1318                                                                   NULL));
1319
1320   MediaSessionOptions opts;
1321   opts.AddStream(MEDIA_TYPE_VIDEO, kVideoTrack1, kMediaStream1);
1322   opts.AddStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
1323   opts.AddStream(MEDIA_TYPE_AUDIO, kAudioTrack2, kMediaStream1);
1324   opts.data_channel_type = cricket::DCT_RTP;
1325   opts.AddStream(MEDIA_TYPE_DATA, kDataTrack1, kMediaStream1);
1326   opts.AddStream(MEDIA_TYPE_DATA, kDataTrack2, kMediaStream1);
1327
1328   rtc::scoped_ptr<SessionDescription>
1329       answer(f2_.CreateAnswer(offer.get(), opts, NULL));
1330
1331   ASSERT_TRUE(answer.get() != NULL);
1332   const ContentInfo* ac = answer->GetContentByName("audio");
1333   const ContentInfo* vc = answer->GetContentByName("video");
1334   const ContentInfo* dc = answer->GetContentByName("data");
1335   ASSERT_TRUE(ac != NULL);
1336   ASSERT_TRUE(vc != NULL);
1337   ASSERT_TRUE(dc != NULL);
1338   const AudioContentDescription* acd =
1339       static_cast<const AudioContentDescription*>(ac->description);
1340   const VideoContentDescription* vcd =
1341       static_cast<const VideoContentDescription*>(vc->description);
1342   const DataContentDescription* dcd =
1343       static_cast<const DataContentDescription*>(dc->description);
1344   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
1345   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
1346   ASSERT_CRYPTO(dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
1347
1348   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
1349   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
1350
1351   const StreamParamsVec& audio_streams = acd->streams();
1352   ASSERT_EQ(2U, audio_streams.size());
1353   EXPECT_TRUE(audio_streams[0].cname ==  audio_streams[1].cname);
1354   EXPECT_EQ(kAudioTrack1, audio_streams[0].id);
1355   ASSERT_EQ(1U, audio_streams[0].ssrcs.size());
1356   EXPECT_NE(0U, audio_streams[0].ssrcs[0]);
1357   EXPECT_EQ(kAudioTrack2, audio_streams[1].id);
1358   ASSERT_EQ(1U, audio_streams[1].ssrcs.size());
1359   EXPECT_NE(0U, audio_streams[1].ssrcs[0]);
1360
1361   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
1362   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
1363
1364   EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
1365   EXPECT_EQ(MAKE_VECTOR(kVideoCodecsAnswer), vcd->codecs());
1366
1367   const StreamParamsVec& video_streams = vcd->streams();
1368   ASSERT_EQ(1U, video_streams.size());
1369   EXPECT_EQ(video_streams[0].cname, audio_streams[0].cname);
1370   EXPECT_EQ(kVideoTrack1, video_streams[0].id);
1371   EXPECT_EQ(kAutoBandwidth, vcd->bandwidth());  // default bandwidth (auto)
1372   EXPECT_TRUE(vcd->rtcp_mux());                 // rtcp-mux defaults on
1373
1374   EXPECT_EQ(MEDIA_TYPE_DATA, dcd->type());
1375   EXPECT_EQ(MAKE_VECTOR(kDataCodecsAnswer), dcd->codecs());
1376
1377   const StreamParamsVec& data_streams = dcd->streams();
1378   ASSERT_EQ(2U, data_streams.size());
1379   EXPECT_TRUE(data_streams[0].cname ==  data_streams[1].cname);
1380   EXPECT_EQ(kDataTrack1, data_streams[0].id);
1381   ASSERT_EQ(1U, data_streams[0].ssrcs.size());
1382   EXPECT_NE(0U, data_streams[0].ssrcs[0]);
1383   EXPECT_EQ(kDataTrack2, data_streams[1].id);
1384   ASSERT_EQ(1U, data_streams[1].ssrcs.size());
1385   EXPECT_NE(0U, data_streams[1].ssrcs[0]);
1386
1387   EXPECT_EQ(cricket::kDataMaxBandwidth,
1388             dcd->bandwidth());                  // default bandwidth (auto)
1389   EXPECT_TRUE(dcd->rtcp_mux());                 // rtcp-mux defaults on
1390
1391   // Update the answer. Add a new video track that is not synched to the
1392   // other traacks and remove 1 audio track.
1393   opts.AddStream(MEDIA_TYPE_VIDEO, kVideoTrack2, kMediaStream2);
1394   opts.RemoveStream(MEDIA_TYPE_AUDIO, kAudioTrack2);
1395   opts.RemoveStream(MEDIA_TYPE_DATA, kDataTrack2);
1396   rtc::scoped_ptr<SessionDescription>
1397       updated_answer(f2_.CreateAnswer(offer.get(), opts, answer.get()));
1398
1399   ASSERT_TRUE(updated_answer.get() != NULL);
1400   ac = updated_answer->GetContentByName("audio");
1401   vc = updated_answer->GetContentByName("video");
1402   dc = updated_answer->GetContentByName("data");
1403   ASSERT_TRUE(ac != NULL);
1404   ASSERT_TRUE(vc != NULL);
1405   ASSERT_TRUE(dc != NULL);
1406   const AudioContentDescription* updated_acd =
1407       static_cast<const AudioContentDescription*>(ac->description);
1408   const VideoContentDescription* updated_vcd =
1409       static_cast<const VideoContentDescription*>(vc->description);
1410   const DataContentDescription* updated_dcd =
1411       static_cast<const DataContentDescription*>(dc->description);
1412
1413   ASSERT_CRYPTO(updated_acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
1414   EXPECT_TRUE(CompareCryptoParams(acd->cryptos(), updated_acd->cryptos()));
1415   ASSERT_CRYPTO(updated_vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
1416   EXPECT_TRUE(CompareCryptoParams(vcd->cryptos(), updated_vcd->cryptos()));
1417   ASSERT_CRYPTO(updated_dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
1418   EXPECT_TRUE(CompareCryptoParams(dcd->cryptos(), updated_dcd->cryptos()));
1419
1420   EXPECT_EQ(acd->type(), updated_acd->type());
1421   EXPECT_EQ(acd->codecs(), updated_acd->codecs());
1422   EXPECT_EQ(vcd->type(), updated_vcd->type());
1423   EXPECT_EQ(vcd->codecs(), updated_vcd->codecs());
1424   EXPECT_EQ(dcd->type(), updated_dcd->type());
1425   EXPECT_EQ(dcd->codecs(), updated_dcd->codecs());
1426
1427   const StreamParamsVec& updated_audio_streams = updated_acd->streams();
1428   ASSERT_EQ(1U, updated_audio_streams.size());
1429   EXPECT_TRUE(audio_streams[0] ==  updated_audio_streams[0]);
1430
1431   const StreamParamsVec& updated_video_streams = updated_vcd->streams();
1432   ASSERT_EQ(2U, updated_video_streams.size());
1433   EXPECT_EQ(video_streams[0], updated_video_streams[0]);
1434   EXPECT_EQ(kVideoTrack2, updated_video_streams[1].id);
1435   EXPECT_NE(updated_video_streams[1].cname, updated_video_streams[0].cname);
1436
1437   const StreamParamsVec& updated_data_streams = updated_dcd->streams();
1438   ASSERT_EQ(1U, updated_data_streams.size());
1439   EXPECT_TRUE(data_streams[0] == updated_data_streams[0]);
1440 }
1441
1442
1443 // Create an updated offer after creating an answer to the original offer and
1444 // verify that the codecs that were part of the original answer are not changed
1445 // in the updated offer.
1446 TEST_F(MediaSessionDescriptionFactoryTest,
1447        RespondentCreatesOfferAfterCreatingAnswer) {
1448   MediaSessionOptions opts;
1449   opts.has_audio = true;
1450   opts.has_video = true;
1451
1452   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
1453   rtc::scoped_ptr<SessionDescription> answer(
1454       f2_.CreateAnswer(offer.get(), opts, NULL));
1455
1456   const AudioContentDescription* acd =
1457       GetFirstAudioContentDescription(answer.get());
1458   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
1459
1460   const VideoContentDescription* vcd =
1461       GetFirstVideoContentDescription(answer.get());
1462   EXPECT_EQ(MAKE_VECTOR(kVideoCodecsAnswer), vcd->codecs());
1463
1464   rtc::scoped_ptr<SessionDescription> updated_offer(
1465       f2_.CreateOffer(opts, answer.get()));
1466
1467   // The expected audio codecs are the common audio codecs from the first
1468   // offer/answer exchange plus the audio codecs only |f2_| offer, sorted in
1469   // preference order.
1470   // TODO(wu): |updated_offer| should not include the codec
1471   // (i.e. |kAudioCodecs2[0]|) the other side doesn't support.
1472   const AudioCodec kUpdatedAudioCodecOffer[] = {
1473     kAudioCodecsAnswer[0],
1474     kAudioCodecsAnswer[1],
1475     kAudioCodecs2[0],
1476   };
1477
1478   // The expected video codecs are the common video codecs from the first
1479   // offer/answer exchange plus the video codecs only |f2_| offer, sorted in
1480   // preference order.
1481   const VideoCodec kUpdatedVideoCodecOffer[] = {
1482     kVideoCodecsAnswer[0],
1483     kVideoCodecs2[1],
1484   };
1485
1486   const AudioContentDescription* updated_acd =
1487       GetFirstAudioContentDescription(updated_offer.get());
1488   EXPECT_EQ(MAKE_VECTOR(kUpdatedAudioCodecOffer), updated_acd->codecs());
1489
1490   const VideoContentDescription* updated_vcd =
1491       GetFirstVideoContentDescription(updated_offer.get());
1492   EXPECT_EQ(MAKE_VECTOR(kUpdatedVideoCodecOffer), updated_vcd->codecs());
1493 }
1494
1495 // Create an updated offer after creating an answer to the original offer and
1496 // verify that the codecs that were part of the original answer are not changed
1497 // in the updated offer. In this test Rtx is enabled.
1498 TEST_F(MediaSessionDescriptionFactoryTest,
1499        RespondentCreatesOfferAfterCreatingAnswerWithRtx) {
1500   MediaSessionOptions opts;
1501   opts.has_video = true;
1502   opts.has_audio = false;
1503   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
1504   VideoCodec rtx_f1;
1505   rtx_f1.id = 126;
1506   rtx_f1.name = cricket::kRtxCodecName;
1507
1508   // This creates rtx for H264 with the payload type |f1_| uses.
1509   rtx_f1.params[cricket::kCodecParamAssociatedPayloadType] =
1510       rtc::ToString<int>(kVideoCodecs1[1].id);
1511   f1_codecs.push_back(rtx_f1);
1512   f1_.set_video_codecs(f1_codecs);
1513
1514   std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
1515   VideoCodec rtx_f2;
1516   rtx_f2.id = 127;
1517   rtx_f2.name = cricket::kRtxCodecName;
1518
1519   // This creates rtx for H264 with the payload type |f2_| uses.
1520   rtx_f2.params[cricket::kCodecParamAssociatedPayloadType] =
1521       rtc::ToString<int>(kVideoCodecs2[0].id);
1522   f2_codecs.push_back(rtx_f2);
1523   f2_.set_video_codecs(f2_codecs);
1524
1525   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
1526   ASSERT_TRUE(offer.get() != NULL);
1527   rtc::scoped_ptr<SessionDescription> answer(
1528       f2_.CreateAnswer(offer.get(), opts, NULL));
1529
1530   const VideoContentDescription* vcd =
1531       GetFirstVideoContentDescription(answer.get());
1532
1533   std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
1534   expected_codecs.push_back(rtx_f1);
1535
1536   EXPECT_EQ(expected_codecs, vcd->codecs());
1537
1538   // Now, make sure we get same result, except for the preference order,
1539   // if |f2_| creates an updated offer even though the default payload types
1540   // are different from |f1_|.
1541   expected_codecs[0].preference = f1_codecs[1].preference;
1542
1543   rtc::scoped_ptr<SessionDescription> updated_offer(
1544       f2_.CreateOffer(opts, answer.get()));
1545   ASSERT_TRUE(updated_offer);
1546   rtc::scoped_ptr<SessionDescription> updated_answer(
1547       f1_.CreateAnswer(updated_offer.get(), opts, answer.get()));
1548
1549   const VideoContentDescription* updated_vcd =
1550       GetFirstVideoContentDescription(updated_answer.get());
1551
1552   EXPECT_EQ(expected_codecs, updated_vcd->codecs());
1553 }
1554
1555 // Create an updated offer that adds video after creating an audio only answer
1556 // to the original offer. This test verifies that if a video codec and the RTX
1557 // codec have the same default payload type as an audio codec that is already in
1558 // use, the added codecs payload types are changed.
1559 TEST_F(MediaSessionDescriptionFactoryTest,
1560        RespondentCreatesOfferWithVideoAndRtxAfterCreatingAudioAnswer) {
1561   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
1562   VideoCodec rtx_f1;
1563   rtx_f1.id = 126;
1564   rtx_f1.name = cricket::kRtxCodecName;
1565
1566   // This creates rtx for H264 with the payload type |f1_| uses.
1567   rtx_f1.params[cricket::kCodecParamAssociatedPayloadType] =
1568       rtc::ToString<int>(kVideoCodecs1[1].id);
1569   f1_codecs.push_back(rtx_f1);
1570   f1_.set_video_codecs(f1_codecs);
1571
1572   MediaSessionOptions opts;
1573   opts.has_audio = true;
1574   opts.has_video = false;
1575
1576   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
1577   rtc::scoped_ptr<SessionDescription> answer(
1578       f2_.CreateAnswer(offer.get(), opts, NULL));
1579
1580   const AudioContentDescription* acd =
1581       GetFirstAudioContentDescription(answer.get());
1582   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
1583
1584   // Now - let |f2_| add video with RTX and let the payload type the RTX codec
1585   // reference  be the same as an audio codec that was negotiated in the
1586   // first offer/answer exchange.
1587   opts.has_audio = true;
1588   opts.has_video = true;
1589
1590   std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
1591   int used_pl_type = acd->codecs()[0].id;
1592   f2_codecs[0].id = used_pl_type;  // Set the payload type for H264.
1593   VideoCodec rtx_f2;
1594   rtx_f2.id = 127;
1595   rtx_f2.name = cricket::kRtxCodecName;
1596   rtx_f2.params[cricket::kCodecParamAssociatedPayloadType] =
1597       rtc::ToString<int>(used_pl_type);
1598   f2_codecs.push_back(rtx_f2);
1599   f2_.set_video_codecs(f2_codecs);
1600
1601   rtc::scoped_ptr<SessionDescription> updated_offer(
1602       f2_.CreateOffer(opts, answer.get()));
1603   ASSERT_TRUE(updated_offer);
1604   rtc::scoped_ptr<SessionDescription> updated_answer(
1605       f1_.CreateAnswer(updated_offer.get(), opts, answer.get()));
1606
1607   const AudioContentDescription* updated_acd =
1608       GetFirstAudioContentDescription(answer.get());
1609   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), updated_acd->codecs());
1610
1611   const VideoContentDescription* updated_vcd =
1612       GetFirstVideoContentDescription(updated_answer.get());
1613
1614   ASSERT_EQ("H264", updated_vcd->codecs()[0].name);
1615   ASSERT_EQ(std::string(cricket::kRtxCodecName), updated_vcd->codecs()[1].name);
1616   int new_h264_pl_type =  updated_vcd->codecs()[0].id;
1617   EXPECT_NE(used_pl_type, new_h264_pl_type);
1618   VideoCodec rtx = updated_vcd->codecs()[1];
1619   int pt_referenced_by_rtx = rtc::FromString<int>(
1620       rtx.params[cricket::kCodecParamAssociatedPayloadType]);
1621   EXPECT_EQ(new_h264_pl_type, pt_referenced_by_rtx);
1622 }
1623
1624 // Test that RTX is ignored when there is no associated payload type parameter.
1625 TEST_F(MediaSessionDescriptionFactoryTest, RtxWithoutApt) {
1626   MediaSessionOptions opts;
1627   opts.has_video = true;
1628   opts.has_audio = false;
1629   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
1630   VideoCodec rtx_f1;
1631   rtx_f1.id = 126;
1632   rtx_f1.name = cricket::kRtxCodecName;
1633
1634   f1_codecs.push_back(rtx_f1);
1635   f1_.set_video_codecs(f1_codecs);
1636
1637   std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
1638   VideoCodec rtx_f2;
1639   rtx_f2.id = 127;
1640   rtx_f2.name = cricket::kRtxCodecName;
1641
1642   // This creates rtx for H264 with the payload type |f2_| uses.
1643   rtx_f2.SetParam(cricket::kCodecParamAssociatedPayloadType,
1644                   rtc::ToString<int>(kVideoCodecs2[0].id));
1645   f2_codecs.push_back(rtx_f2);
1646   f2_.set_video_codecs(f2_codecs);
1647
1648   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
1649   ASSERT_TRUE(offer.get() != NULL);
1650   // kCodecParamAssociatedPayloadType will always be added to the offer when RTX
1651   // is selected. Manually remove kCodecParamAssociatedPayloadType so that it
1652   // is possible to test that that RTX is dropped when
1653   // kCodecParamAssociatedPayloadType is missing in the offer.
1654   VideoContentDescription* desc =
1655       static_cast<cricket::VideoContentDescription*>(
1656           offer->GetContentDescriptionByName(cricket::CN_VIDEO));
1657   ASSERT_TRUE(desc != NULL);
1658   std::vector<VideoCodec> codecs = desc->codecs();
1659   for (std::vector<VideoCodec>::iterator iter = codecs.begin();
1660        iter != codecs.end(); ++iter) {
1661     if (iter->name.find(cricket::kRtxCodecName) == 0) {
1662       iter->params.clear();
1663     }
1664   }
1665   desc->set_codecs(codecs);
1666
1667   rtc::scoped_ptr<SessionDescription> answer(
1668       f2_.CreateAnswer(offer.get(), opts, NULL));
1669
1670   const VideoContentDescription* vcd =
1671       GetFirstVideoContentDescription(answer.get());
1672
1673   for (std::vector<VideoCodec>::const_iterator iter = vcd->codecs().begin();
1674        iter != vcd->codecs().end(); ++iter) {
1675     ASSERT_STRNE(iter->name.c_str(), cricket::kRtxCodecName);
1676   }
1677 }
1678
1679 // Create an updated offer after creating an answer to the original offer and
1680 // verify that the RTP header extensions that were part of the original answer
1681 // are not changed in the updated offer.
1682 TEST_F(MediaSessionDescriptionFactoryTest,
1683        RespondentCreatesOfferAfterCreatingAnswerWithRtpExtensions) {
1684   MediaSessionOptions opts;
1685   opts.has_audio = true;
1686   opts.has_video = true;
1687
1688   f1_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension1));
1689   f1_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension1));
1690   f2_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension2));
1691   f2_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension2));
1692
1693   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
1694   rtc::scoped_ptr<SessionDescription> answer(
1695       f2_.CreateAnswer(offer.get(), opts, NULL));
1696
1697   EXPECT_EQ(MAKE_VECTOR(kAudioRtpExtensionAnswer),
1698             GetFirstAudioContentDescription(
1699                 answer.get())->rtp_header_extensions());
1700   EXPECT_EQ(MAKE_VECTOR(kVideoRtpExtensionAnswer),
1701             GetFirstVideoContentDescription(
1702                 answer.get())->rtp_header_extensions());
1703
1704   rtc::scoped_ptr<SessionDescription> updated_offer(
1705       f2_.CreateOffer(opts, answer.get()));
1706
1707   // The expected RTP header extensions in the new offer are the resulting
1708   // extensions from the first offer/answer exchange plus the extensions only
1709   // |f2_| offer.
1710   // Since the default local extension id |f2_| uses has already been used by
1711   // |f1_| for another extensions, it is changed to 13.
1712   const RtpHeaderExtension kUpdatedAudioRtpExtensions[] = {
1713     kAudioRtpExtensionAnswer[0],
1714     RtpHeaderExtension(kAudioRtpExtension2[1].uri, 13),
1715     kAudioRtpExtension2[2],
1716   };
1717
1718   // Since the default local extension id |f2_| uses has already been used by
1719   // |f1_| for another extensions, is is changed to 12.
1720   const RtpHeaderExtension kUpdatedVideoRtpExtensions[] = {
1721     kVideoRtpExtensionAnswer[0],
1722     RtpHeaderExtension(kVideoRtpExtension2[1].uri, 12),
1723     kVideoRtpExtension2[2],
1724   };
1725
1726   const AudioContentDescription* updated_acd =
1727       GetFirstAudioContentDescription(updated_offer.get());
1728   EXPECT_EQ(MAKE_VECTOR(kUpdatedAudioRtpExtensions),
1729             updated_acd->rtp_header_extensions());
1730
1731   const VideoContentDescription* updated_vcd =
1732       GetFirstVideoContentDescription(updated_offer.get());
1733   EXPECT_EQ(MAKE_VECTOR(kUpdatedVideoRtpExtensions),
1734             updated_vcd->rtp_header_extensions());
1735 }
1736
1737 TEST(MediaSessionDescription, CopySessionDescription) {
1738   SessionDescription source;
1739   cricket::ContentGroup group(cricket::CN_AUDIO);
1740   source.AddGroup(group);
1741   AudioContentDescription* acd(new AudioContentDescription());
1742   acd->set_codecs(MAKE_VECTOR(kAudioCodecs1));
1743   acd->AddLegacyStream(1);
1744   source.AddContent(cricket::CN_AUDIO, cricket::NS_JINGLE_RTP, acd);
1745   VideoContentDescription* vcd(new VideoContentDescription());
1746   vcd->set_codecs(MAKE_VECTOR(kVideoCodecs1));
1747   vcd->AddLegacyStream(2);
1748   source.AddContent(cricket::CN_VIDEO, cricket::NS_JINGLE_RTP, vcd);
1749
1750   rtc::scoped_ptr<SessionDescription> copy(source.Copy());
1751   ASSERT_TRUE(copy.get() != NULL);
1752   EXPECT_TRUE(copy->HasGroup(cricket::CN_AUDIO));
1753   const ContentInfo* ac = copy->GetContentByName("audio");
1754   const ContentInfo* vc = copy->GetContentByName("video");
1755   ASSERT_TRUE(ac != NULL);
1756   ASSERT_TRUE(vc != NULL);
1757   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
1758   const AudioContentDescription* acd_copy =
1759       static_cast<const AudioContentDescription*>(ac->description);
1760   EXPECT_EQ(acd->codecs(), acd_copy->codecs());
1761   EXPECT_EQ(1u, acd->first_ssrc());
1762
1763   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
1764   const VideoContentDescription* vcd_copy =
1765       static_cast<const VideoContentDescription*>(vc->description);
1766   EXPECT_EQ(vcd->codecs(), vcd_copy->codecs());
1767   EXPECT_EQ(2u, vcd->first_ssrc());
1768 }
1769
1770 // The below TestTransportInfoXXX tests create different offers/answers, and
1771 // ensure the TransportInfo in the SessionDescription matches what we expect.
1772 TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferAudio) {
1773   MediaSessionOptions options;
1774   options.has_audio = true;
1775   TestTransportInfo(true, options, false);
1776 }
1777
1778 TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferAudioCurrent) {
1779   MediaSessionOptions options;
1780   options.has_audio = true;
1781   TestTransportInfo(true, options, true);
1782 }
1783
1784 TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferMultimedia) {
1785   MediaSessionOptions options;
1786   options.has_audio = true;
1787   options.has_video = true;
1788   options.data_channel_type = cricket::DCT_RTP;
1789   TestTransportInfo(true, options, false);
1790 }
1791
1792 TEST_F(MediaSessionDescriptionFactoryTest,
1793     TestTransportInfoOfferMultimediaCurrent) {
1794   MediaSessionOptions options;
1795   options.has_audio = true;
1796   options.has_video = true;
1797   options.data_channel_type = cricket::DCT_RTP;
1798   TestTransportInfo(true, options, true);
1799 }
1800
1801 TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferBundle) {
1802   MediaSessionOptions options;
1803   options.has_audio = true;
1804   options.has_video = true;
1805   options.data_channel_type = cricket::DCT_RTP;
1806   options.bundle_enabled = true;
1807   TestTransportInfo(true, options, false);
1808 }
1809
1810 TEST_F(MediaSessionDescriptionFactoryTest,
1811        TestTransportInfoOfferBundleCurrent) {
1812   MediaSessionOptions options;
1813   options.has_audio = true;
1814   options.has_video = true;
1815   options.data_channel_type = cricket::DCT_RTP;
1816   options.bundle_enabled = true;
1817   TestTransportInfo(true, options, true);
1818 }
1819
1820 TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoAnswerAudio) {
1821   MediaSessionOptions options;
1822   options.has_audio = true;
1823   TestTransportInfo(false, options, false);
1824 }
1825
1826 TEST_F(MediaSessionDescriptionFactoryTest,
1827     TestTransportInfoAnswerAudioCurrent) {
1828   MediaSessionOptions options;
1829   options.has_audio = true;
1830   TestTransportInfo(false, options, true);
1831 }
1832
1833 TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoAnswerMultimedia) {
1834   MediaSessionOptions options;
1835   options.has_audio = true;
1836   options.has_video = true;
1837   options.data_channel_type = cricket::DCT_RTP;
1838   TestTransportInfo(false, options, false);
1839 }
1840
1841 TEST_F(MediaSessionDescriptionFactoryTest,
1842     TestTransportInfoAnswerMultimediaCurrent) {
1843   MediaSessionOptions options;
1844   options.has_audio = true;
1845   options.has_video = true;
1846   options.data_channel_type = cricket::DCT_RTP;
1847   TestTransportInfo(false, options, true);
1848 }
1849
1850 TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoAnswerBundle) {
1851   MediaSessionOptions options;
1852   options.has_audio = true;
1853   options.has_video = true;
1854   options.data_channel_type = cricket::DCT_RTP;
1855   options.bundle_enabled = true;
1856   TestTransportInfo(false, options, false);
1857 }
1858
1859 TEST_F(MediaSessionDescriptionFactoryTest,
1860     TestTransportInfoAnswerBundleCurrent) {
1861   MediaSessionOptions options;
1862   options.has_audio = true;
1863   options.has_video = true;
1864   options.data_channel_type = cricket::DCT_RTP;
1865   options.bundle_enabled = true;
1866   TestTransportInfo(false, options, true);
1867 }
1868
1869 // Create an offer with bundle enabled and verify the crypto parameters are
1870 // the common set of the available cryptos.
1871 TEST_F(MediaSessionDescriptionFactoryTest, TestCryptoWithOfferBundle) {
1872   TestCryptoWithBundle(true);
1873 }
1874
1875 // Create an answer with bundle enabled and verify the crypto parameters are
1876 // the common set of the available cryptos.
1877 TEST_F(MediaSessionDescriptionFactoryTest, TestCryptoWithAnswerBundle) {
1878   TestCryptoWithBundle(false);
1879 }
1880
1881 // Verifies that creating answer fails if the offer has UDP/TLS/RTP/SAVPF but
1882 // DTLS is not enabled locally.
1883 TEST_F(MediaSessionDescriptionFactoryTest,
1884        TestOfferDtlsSavpfWithoutDtlsFailed) {
1885   f1_.set_secure(SEC_ENABLED);
1886   f2_.set_secure(SEC_ENABLED);
1887   tdf1_.set_secure(SEC_DISABLED);
1888   tdf2_.set_secure(SEC_DISABLED);
1889
1890   rtc::scoped_ptr<SessionDescription> offer(
1891       f1_.CreateOffer(MediaSessionOptions(), NULL));
1892   ASSERT_TRUE(offer.get() != NULL);
1893   ContentInfo* offer_content = offer->GetContentByName("audio");
1894   ASSERT_TRUE(offer_content != NULL);
1895   AudioContentDescription* offer_audio_desc =
1896       static_cast<AudioContentDescription*>(offer_content->description);
1897   offer_audio_desc->set_protocol(cricket::kMediaProtocolDtlsSavpf);
1898
1899   rtc::scoped_ptr<SessionDescription> answer(
1900       f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
1901   ASSERT_TRUE(answer != NULL);
1902   ContentInfo* answer_content = answer->GetContentByName("audio");
1903   ASSERT_TRUE(answer_content != NULL);
1904
1905   ASSERT_TRUE(answer_content->rejected);
1906 }
1907
1908 // Offers UDP/TLS/RTP/SAVPF and verifies the answer can be created and contains
1909 // UDP/TLS/RTP/SAVPF.
1910 TEST_F(MediaSessionDescriptionFactoryTest, TestOfferDtlsSavpfCreateAnswer) {
1911   f1_.set_secure(SEC_ENABLED);
1912   f2_.set_secure(SEC_ENABLED);
1913   tdf1_.set_secure(SEC_ENABLED);
1914   tdf2_.set_secure(SEC_ENABLED);
1915
1916   rtc::scoped_ptr<SessionDescription> offer(
1917       f1_.CreateOffer(MediaSessionOptions(), NULL));
1918   ASSERT_TRUE(offer.get() != NULL);
1919   ContentInfo* offer_content = offer->GetContentByName("audio");
1920   ASSERT_TRUE(offer_content != NULL);
1921   AudioContentDescription* offer_audio_desc =
1922       static_cast<AudioContentDescription*>(offer_content->description);
1923   offer_audio_desc->set_protocol(cricket::kMediaProtocolDtlsSavpf);
1924
1925   rtc::scoped_ptr<SessionDescription> answer(
1926       f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
1927   ASSERT_TRUE(answer != NULL);
1928
1929   const ContentInfo* answer_content = answer->GetContentByName("audio");
1930   ASSERT_TRUE(answer_content != NULL);
1931   ASSERT_FALSE(answer_content->rejected);
1932
1933   const AudioContentDescription* answer_audio_desc =
1934       static_cast<const AudioContentDescription*>(answer_content->description);
1935   EXPECT_EQ(std::string(cricket::kMediaProtocolDtlsSavpf),
1936                         answer_audio_desc->protocol());
1937 }
1938
1939 // Test that we include both SDES and DTLS in the offer, but only include SDES
1940 // in the answer if DTLS isn't negotiated.
1941 TEST_F(MediaSessionDescriptionFactoryTest, TestCryptoDtls) {
1942   f1_.set_secure(SEC_ENABLED);
1943   f2_.set_secure(SEC_ENABLED);
1944   tdf1_.set_secure(SEC_ENABLED);
1945   tdf2_.set_secure(SEC_DISABLED);
1946   MediaSessionOptions options;
1947   options.has_audio = true;
1948   options.has_video = true;
1949   rtc::scoped_ptr<SessionDescription> offer, answer;
1950   const cricket::MediaContentDescription* audio_media_desc;
1951   const cricket::MediaContentDescription* video_media_desc;
1952   const cricket::TransportDescription* audio_trans_desc;
1953   const cricket::TransportDescription* video_trans_desc;
1954
1955   // Generate an offer with SDES and DTLS support.
1956   offer.reset(f1_.CreateOffer(options, NULL));
1957   ASSERT_TRUE(offer.get() != NULL);
1958
1959   audio_media_desc = static_cast<const cricket::MediaContentDescription*>(
1960       offer->GetContentDescriptionByName("audio"));
1961   ASSERT_TRUE(audio_media_desc != NULL);
1962   video_media_desc = static_cast<const cricket::MediaContentDescription*>(
1963       offer->GetContentDescriptionByName("video"));
1964   ASSERT_TRUE(video_media_desc != NULL);
1965   EXPECT_EQ(2u, audio_media_desc->cryptos().size());
1966   EXPECT_EQ(1u, video_media_desc->cryptos().size());
1967
1968   audio_trans_desc = offer->GetTransportDescriptionByName("audio");
1969   ASSERT_TRUE(audio_trans_desc != NULL);
1970   video_trans_desc = offer->GetTransportDescriptionByName("video");
1971   ASSERT_TRUE(video_trans_desc != NULL);
1972   ASSERT_TRUE(audio_trans_desc->identity_fingerprint.get() != NULL);
1973   ASSERT_TRUE(video_trans_desc->identity_fingerprint.get() != NULL);
1974
1975   // Generate an answer with only SDES support, since tdf2 has crypto disabled.
1976   answer.reset(f2_.CreateAnswer(offer.get(), options, NULL));
1977   ASSERT_TRUE(answer.get() != NULL);
1978
1979   audio_media_desc = static_cast<const cricket::MediaContentDescription*>(
1980       answer->GetContentDescriptionByName("audio"));
1981   ASSERT_TRUE(audio_media_desc != NULL);
1982   video_media_desc = static_cast<const cricket::MediaContentDescription*>(
1983       answer->GetContentDescriptionByName("video"));
1984   ASSERT_TRUE(video_media_desc != NULL);
1985   EXPECT_EQ(1u, audio_media_desc->cryptos().size());
1986   EXPECT_EQ(1u, video_media_desc->cryptos().size());
1987
1988   audio_trans_desc = answer->GetTransportDescriptionByName("audio");
1989   ASSERT_TRUE(audio_trans_desc != NULL);
1990   video_trans_desc = answer->GetTransportDescriptionByName("video");
1991   ASSERT_TRUE(video_trans_desc != NULL);
1992   ASSERT_TRUE(audio_trans_desc->identity_fingerprint.get() == NULL);
1993   ASSERT_TRUE(video_trans_desc->identity_fingerprint.get() == NULL);
1994
1995   // Enable DTLS; the answer should now only have DTLS support.
1996   tdf2_.set_secure(SEC_ENABLED);
1997   answer.reset(f2_.CreateAnswer(offer.get(), options, NULL));
1998   ASSERT_TRUE(answer.get() != NULL);
1999
2000   audio_media_desc = static_cast<const cricket::MediaContentDescription*>(
2001       answer->GetContentDescriptionByName("audio"));
2002   ASSERT_TRUE(audio_media_desc != NULL);
2003   video_media_desc = static_cast<const cricket::MediaContentDescription*>(
2004       answer->GetContentDescriptionByName("video"));
2005   ASSERT_TRUE(video_media_desc != NULL);
2006   EXPECT_TRUE(audio_media_desc->cryptos().empty());
2007   EXPECT_TRUE(video_media_desc->cryptos().empty());
2008   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
2009             audio_media_desc->protocol());
2010   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
2011             video_media_desc->protocol());
2012
2013   audio_trans_desc = answer->GetTransportDescriptionByName("audio");
2014   ASSERT_TRUE(audio_trans_desc != NULL);
2015   video_trans_desc = answer->GetTransportDescriptionByName("video");
2016   ASSERT_TRUE(video_trans_desc != NULL);
2017   ASSERT_TRUE(audio_trans_desc->identity_fingerprint.get() != NULL);
2018   ASSERT_TRUE(video_trans_desc->identity_fingerprint.get() != NULL);
2019
2020   // Try creating offer again. DTLS enabled now, crypto's should be empty
2021   // in new offer.
2022   offer.reset(f1_.CreateOffer(options, offer.get()));
2023   ASSERT_TRUE(offer.get() != NULL);
2024   audio_media_desc = static_cast<const cricket::MediaContentDescription*>(
2025       offer->GetContentDescriptionByName("audio"));
2026   ASSERT_TRUE(audio_media_desc != NULL);
2027   video_media_desc = static_cast<const cricket::MediaContentDescription*>(
2028       offer->GetContentDescriptionByName("video"));
2029   ASSERT_TRUE(video_media_desc != NULL);
2030   EXPECT_TRUE(audio_media_desc->cryptos().empty());
2031   EXPECT_TRUE(video_media_desc->cryptos().empty());
2032
2033   audio_trans_desc = offer->GetTransportDescriptionByName("audio");
2034   ASSERT_TRUE(audio_trans_desc != NULL);
2035   video_trans_desc = offer->GetTransportDescriptionByName("video");
2036   ASSERT_TRUE(video_trans_desc != NULL);
2037   ASSERT_TRUE(audio_trans_desc->identity_fingerprint.get() != NULL);
2038   ASSERT_TRUE(video_trans_desc->identity_fingerprint.get() != NULL);
2039 }
2040
2041 // Test that an answer can't be created if cryptos are required but the offer is
2042 // unsecure.
2043 TEST_F(MediaSessionDescriptionFactoryTest, TestSecureAnswerToUnsecureOffer) {
2044   MediaSessionOptions options;
2045   f1_.set_secure(SEC_DISABLED);
2046   tdf1_.set_secure(SEC_DISABLED);
2047   f2_.set_secure(SEC_REQUIRED);
2048   tdf1_.set_secure(SEC_ENABLED);
2049
2050   rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(options,
2051                                                                   NULL));
2052   ASSERT_TRUE(offer.get() != NULL);
2053   rtc::scoped_ptr<SessionDescription> answer(
2054       f2_.CreateAnswer(offer.get(), options, NULL));
2055   EXPECT_TRUE(answer.get() == NULL);
2056 }
2057
2058 // Test that we accept a DTLS offer without SDES and create an appropriate
2059 // answer.
2060 TEST_F(MediaSessionDescriptionFactoryTest, TestCryptoOfferDtlsButNotSdes) {
2061   f1_.set_secure(SEC_DISABLED);
2062   f2_.set_secure(SEC_ENABLED);
2063   tdf1_.set_secure(SEC_ENABLED);
2064   tdf2_.set_secure(SEC_ENABLED);
2065   MediaSessionOptions options;
2066   options.has_audio = true;
2067   options.has_video = true;
2068   options.data_channel_type = cricket::DCT_RTP;
2069
2070   rtc::scoped_ptr<SessionDescription> offer, answer;
2071
2072   // Generate an offer with DTLS but without SDES.
2073   offer.reset(f1_.CreateOffer(options, NULL));
2074   ASSERT_TRUE(offer.get() != NULL);
2075
2076   const AudioContentDescription* audio_offer =
2077       GetFirstAudioContentDescription(offer.get());
2078   ASSERT_TRUE(audio_offer->cryptos().empty());
2079   const VideoContentDescription* video_offer =
2080       GetFirstVideoContentDescription(offer.get());
2081   ASSERT_TRUE(video_offer->cryptos().empty());
2082   const DataContentDescription* data_offer =
2083       GetFirstDataContentDescription(offer.get());
2084   ASSERT_TRUE(data_offer->cryptos().empty());
2085
2086   const cricket::TransportDescription* audio_offer_trans_desc =
2087       offer->GetTransportDescriptionByName("audio");
2088   ASSERT_TRUE(audio_offer_trans_desc->identity_fingerprint.get() != NULL);
2089   const cricket::TransportDescription* video_offer_trans_desc =
2090       offer->GetTransportDescriptionByName("video");
2091   ASSERT_TRUE(video_offer_trans_desc->identity_fingerprint.get() != NULL);
2092   const cricket::TransportDescription* data_offer_trans_desc =
2093       offer->GetTransportDescriptionByName("data");
2094   ASSERT_TRUE(data_offer_trans_desc->identity_fingerprint.get() != NULL);
2095
2096   // Generate an answer with DTLS.
2097   answer.reset(f2_.CreateAnswer(offer.get(), options, NULL));
2098   ASSERT_TRUE(answer.get() != NULL);
2099
2100   const cricket::TransportDescription* audio_answer_trans_desc =
2101       answer->GetTransportDescriptionByName("audio");
2102   EXPECT_TRUE(audio_answer_trans_desc->identity_fingerprint.get() != NULL);
2103   const cricket::TransportDescription* video_answer_trans_desc =
2104       answer->GetTransportDescriptionByName("video");
2105   EXPECT_TRUE(video_answer_trans_desc->identity_fingerprint.get() != NULL);
2106   const cricket::TransportDescription* data_answer_trans_desc =
2107       answer->GetTransportDescriptionByName("data");
2108   EXPECT_TRUE(data_answer_trans_desc->identity_fingerprint.get() != NULL);
2109 }
2110
2111 // Verifies if vad_enabled option is set to false, CN codecs are not present in
2112 // offer or answer.
2113 TEST_F(MediaSessionDescriptionFactoryTest, TestVADEnableOption) {
2114   MediaSessionOptions options;
2115   options.has_audio = true;
2116   options.has_video = true;
2117   rtc::scoped_ptr<SessionDescription> offer(
2118       f1_.CreateOffer(options, NULL));
2119   ASSERT_TRUE(offer.get() != NULL);
2120   const ContentInfo* audio_content = offer->GetContentByName("audio");
2121   EXPECT_FALSE(VerifyNoCNCodecs(audio_content));
2122
2123   options.vad_enabled = false;
2124   offer.reset(f1_.CreateOffer(options, NULL));
2125   ASSERT_TRUE(offer.get() != NULL);
2126   audio_content = offer->GetContentByName("audio");
2127   EXPECT_TRUE(VerifyNoCNCodecs(audio_content));
2128   rtc::scoped_ptr<SessionDescription> answer(
2129       f1_.CreateAnswer(offer.get(), options, NULL));
2130   ASSERT_TRUE(answer.get() != NULL);
2131   audio_content = answer->GetContentByName("audio");
2132   EXPECT_TRUE(VerifyNoCNCodecs(audio_content));
2133 }