Revert change which removes GICE

talk/app/webrtc/webrtcsdp_unittest.cc

 /*
  * libjingle
  * Copyright 2011 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 37 matching lines @@
 using cricket::ContentInfo;
 using cricket::CryptoParams;
 using cricket::ContentGroup;
 using cricket::DataCodec;
 using cricket::DataContentDescription;
 using cricket::ICE_CANDIDATE_COMPONENT_RTCP;
 using cricket::ICE_CANDIDATE_COMPONENT_RTP;
 using cricket::kFecSsrcGroupSemantics;
 using cricket::LOCAL_PORT_TYPE;
 using cricket::NS_JINGLE_DRAFT_SCTP;
+using cricket::NS_JINGLE_ICE_UDP;
 using cricket::NS_JINGLE_RTP;
 using cricket::RtpHeaderExtension;
 using cricket::RELAY_PORT_TYPE;
 using cricket::SessionDescription;
 using cricket::StreamParams;
 using cricket::STUN_PORT_TYPE;
 using cricket::TransportDescription;
 using cricket::TransportInfo;
 using cricket::VideoCodec;
 using cricket::VideoContentDescription;
@@ skipping 504 matching lines @@
         JsepSessionDescription::kMaxVideoCodecHeight,
         JsepSessionDescription::kDefaultVideoCodecFramerate,
         JsepSessionDescription::kDefaultVideoCodecPreference));
 
     desc_.AddContent(kVideoContentName, NS_JINGLE_RTP,
                      video.release());
 
     // TransportInfo
     EXPECT_TRUE(desc_.AddTransportInfo(
         TransportInfo(kAudioContentName,
-                      TransportDescription(kCandidateUfragVoice,
+                      TransportDescription(NS_JINGLE_ICE_UDP,
+                                           kCandidateUfragVoice,
                                            kCandidatePwdVoice))));
     EXPECT_TRUE(desc_.AddTransportInfo(
         TransportInfo(kVideoContentName,
-                      TransportDescription(kCandidateUfragVideo,
+                      TransportDescription(NS_JINGLE_ICE_UDP,
+                                           kCandidateUfragVideo,
                                            kCandidatePwdVideo))));
 
     // v4 host
     int port = 1234;
     rtc::SocketAddress address("192.168.1.5", port++);
     Candidate candidate1(ICE_CANDIDATE_COMPONENT_RTP, "udp", address,
                          kCandidatePriority, "", "", LOCAL_PORT_TYPE,
                          kCandidateGeneration, kCandidateFoundation1);
     address.SetPort(port++);
     Candidate candidate2(ICE_CANDIDATE_COMPONENT_RTCP, "udp", address,
@@ skipping 256 matching lines @@
     const cricket::TransportInfos transports2 = desc2.transport_infos();
     EXPECT_EQ(transports1.size(), transports2.size());
     if (transports1.size() != transports2.size()) {
       ADD_FAILURE();
       return;
     }
     for (size_t i = 0; i < transports1.size(); ++i) {
       const cricket::TransportInfo transport1 = transports1.at(i);
       const cricket::TransportInfo transport2 = transports2.at(i);
       EXPECT_EQ(transport1.content_name, transport2.content_name);
+      EXPECT_EQ(transport1.description.transport_type,
+                transport2.description.transport_type);
       EXPECT_EQ(transport1.description.ice_ufrag,
                 transport2.description.ice_ufrag);
       EXPECT_EQ(transport1.description.ice_pwd,
                 transport2.description.ice_pwd);
       if (transport1.description.identity_fingerprint) {
         EXPECT_EQ(*transport1.description.identity_fingerprint,
                   *transport2.description.identity_fingerprint);
       } else {
         EXPECT_EQ(transport1.description.identity_fingerprint.get(),
                   transport2.description.identity_fingerprint.get());
@@ skipping 60 matching lines @@
       const std::string& ufrag, const std::string& pwd) {
     std::string content_name;
     if (mline_index == 0) {
       content_name = kAudioContentName;
     } else if (mline_index == 1) {
       content_name = kVideoContentName;
     } else {
       ASSERT(false);
     }
     TransportInfo transport_info(
-        content_name, TransportDescription(ufrag, pwd));
+        content_name, TransportDescription(NS_JINGLE_ICE_UDP,
+                                           ufrag, pwd));
     SessionDescription* desc =
         const_cast<SessionDescription*>(jdesc->description());
     desc->RemoveTransportInfoByName(content_name);
     EXPECT_TRUE(desc->AddTransportInfo(transport_info));
     for (size_t i = 0; i < jdesc_.number_of_mediasections(); ++i) {
       const IceCandidateCollection* cc = jdesc_.candidates(i);
       for (size_t j = 0; j < cc->count(); ++j) {
         if (cc->at(j)->sdp_mline_index() == mline_index) {
           const_cast<Candidate&>(cc->at(j)->candidate()).set_username(
               ufrag);
@@ skipping 16 matching lines @@
   }
 
   void AddFingerprint() {
     desc_.RemoveTransportInfoByName(kAudioContentName);
     desc_.RemoveTransportInfoByName(kVideoContentName);
     rtc::SSLFingerprint fingerprint(rtc::DIGEST_SHA_1,
                                           kIdentityDigest,
                                           sizeof(kIdentityDigest));
     EXPECT_TRUE(desc_.AddTransportInfo(
         TransportInfo(kAudioContentName,
-                      TransportDescription(std::vector<std::string>(),
+                      TransportDescription(NS_JINGLE_ICE_UDP,
+                                           std::vector<std::string>(),
                                            kCandidateUfragVoice,
                                            kCandidatePwdVoice,
                                            cricket::ICEMODE_FULL,
                                            cricket::CONNECTIONROLE_NONE,
                                            &fingerprint, Candidates()))));
     EXPECT_TRUE(desc_.AddTransportInfo(
         TransportInfo(kVideoContentName,
-                      TransportDescription(std::vector<std::string>(),
+                      TransportDescription(NS_JINGLE_ICE_UDP,
+                                           std::vector<std::string>(),
                                            kCandidateUfragVideo,
                                            kCandidatePwdVideo,
                                            cricket::ICEMODE_FULL,
                                            cricket::CONNECTIONROLE_NONE,
                                            &fingerprint, Candidates()))));
   }
 
   void AddExtmap() {
     audio_desc_ = static_cast<AudioContentDescription*>(
         audio_desc_->Copy());
@@ skipping 59 matching lines @@
         new DataContentDescription());
     data_desc_ = data.get();
     data_desc_->set_protocol(cricket::kMediaProtocolDtlsSctp);
     DataCodec codec(cricket::kGoogleSctpDataCodecId,
                     cricket::kGoogleSctpDataCodecName, 0);
     codec.SetParam(cricket::kCodecParamPort, kDefaultSctpPort);
     data_desc_->AddCodec(codec);
     desc_.AddContent(kDataContentName, NS_JINGLE_DRAFT_SCTP, data.release());
     EXPECT_TRUE(desc_.AddTransportInfo(
            TransportInfo(kDataContentName,
-                         TransportDescription(kCandidateUfragData,
+                         TransportDescription(NS_JINGLE_ICE_UDP,
+                                              kCandidateUfragData,
                                               kCandidatePwdData))));
   }
 
   void AddRtpDataChannel() {
     rtc::scoped_ptr<DataContentDescription> data(
         new DataContentDescription());
     data_desc_ = data.get();
 
     data_desc_->AddCodec(DataCodec(101, "google-data", 1));
     StreamParams data_stream;
     data_stream.id = kDataChannelMsid;
     data_stream.cname = kDataChannelCname;
     data_stream.sync_label = kDataChannelLabel;
     data_stream.ssrcs.push_back(kDataChannelSsrc);
     data_desc_->AddStream(data_stream);
     data_desc_->AddCrypto(CryptoParams(
         1, "AES_CM_128_HMAC_SHA1_80",
         "inline:FvLcvU2P3ZWmQxgPAgcDu7Zl9vftYElFOjEzhWs5", ""));
     data_desc_->set_protocol(cricket::kMediaProtocolSavpf);
     desc_.AddContent(kDataContentName, NS_JINGLE_RTP, data.release());
     EXPECT_TRUE(desc_.AddTransportInfo(
            TransportInfo(kDataContentName,
-                         TransportDescription(kCandidateUfragData,
+                         TransportDescription(NS_JINGLE_ICE_UDP,
+                                              kCandidateUfragData,
                                               kCandidatePwdData))));
   }
 
   bool TestDeserializeDirection(cricket::MediaContentDirection direction) {
     std::string new_sdp = kSdpFullString;
     ReplaceDirection(direction, &new_sdp);
     JsepSessionDescription new_jdesc(kDummyString);
 
     EXPECT_TRUE(SdpDeserialize(new_sdp, &new_jdesc));
 
@@ skipping 1562 matching lines @@
       const cricket::MediaContentDescription* mdesc =
           static_cast<const cricket::MediaContentDescription*>(
               desc->contents()[i].description);
       EXPECT_EQ(media_types[media_content_in_sdp[i]], mdesc->type());
     }
 
     std::string serialized_sdp = webrtc::SdpSerialize(jdesc);
     EXPECT_EQ(sdp_string, serialized_sdp);
   }
 }