Track pending ICE restarts independently for different media sections.

talk/app/webrtc/webrtcsession_unittest.cc

 /*
  * libjingle
  * Copyright 2012 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 775 matching lines @@
       }
       if (transport_desc1->ice_pwd != transport_desc2->ice_pwd ||
           transport_desc1->ice_ufrag != transport_desc2->ice_ufrag) {
         EXPECT_FALSE(expect_equal);
         return;
       }
     }
     EXPECT_TRUE(expect_equal);
   }
 
+  // Compares ufrag/password only for the specified media type.
+  void CompareIceUfragAndPassword(const cricket::SessionDescription* desc1,
+                                  const cricket::SessionDescription* desc2,
+                                  cricket::MediaType media_type,
+                                  bool expect_equal) {
+    if (desc1->contents().size() != desc2->contents().size()) {
+      EXPECT_FALSE(expect_equal);
+      return;
+    }
+
+    const cricket::ContentInfo* cinfo =
+        cricket::GetFirstMediaContent(desc1->contents(), media_type);
+    const cricket::TransportDescription* transport_desc1 =
+        desc1->GetTransportDescriptionByName(cinfo->name);
+    const cricket::TransportDescription* transport_desc2 =
+        desc2->GetTransportDescriptionByName(cinfo->name);
+    if (!transport_desc1 || !transport_desc2) {
+      EXPECT_FALSE(expect_equal);
+      return;
+    }
+    if (transport_desc1->ice_pwd != transport_desc2->ice_pwd ||
+        transport_desc1->ice_ufrag != transport_desc2->ice_ufrag) {
+      EXPECT_FALSE(expect_equal);
+      return;
+    }
+    EXPECT_TRUE(expect_equal);
+  }
+
   void RemoveIceUfragPwdLines(const SessionDescriptionInterface* current_desc,
                               std::string *sdp) {
     const cricket::SessionDescription* desc = current_desc->description();
     EXPECT_TRUE(current_desc->ToString(sdp));
 
     const cricket::ContentInfos& contents = desc->contents();
     cricket::ContentInfos::const_iterator it = contents.begin();
     // Replace ufrag and pwd lines with empty strings.
     for (; it != contents.end(); ++it) {
       const cricket::TransportDescription* transport_desc =
@@ skipping 33 matching lines @@
       std::string mod_pwd = "a=ice-pwd:" + modified_ice_pwd + "\r\n";
       rtc::replace_substrs(ufrag_line.c_str(), ufrag_line.length(),
                                  mod_ufrag.c_str(), mod_ufrag.length(),
                                  sdp);
       rtc::replace_substrs(pwd_line.c_str(), pwd_line.length(),
                                  mod_pwd.c_str(), mod_pwd.length(),
                                  sdp);
     }
   }
 
+  // Modifies ufrag/pwd for specified |media_type|, by directly modifying the
+  // description.
+  void ModifyIceUfragPwd(SessionDescriptionInterface* current_desc,
+                         cricket::MediaType media_type,
+                         const std::string& modified_ice_ufrag,
+                         const std::string& modified_ice_pwd) {
+    cricket::SessionDescription* desc = current_desc->description();
+    const cricket::ContentInfo* cinfo =
+        cricket::GetFirstMediaContent(desc->contents(), media_type);
+    // Replace ufrag and pwd with |modified_ice_ufrag| and
+    // |modified_ice_pwd| strings.
+    TransportInfo* transport_info = desc->GetTransportInfoByName(cinfo->name);
+    cricket::TransportDescription* transport_desc =
+        &transport_info->description;
+    transport_desc->ice_ufrag = modified_ice_ufrag;
+    transport_desc->ice_pwd = modified_ice_pwd;
+  }
+
   // Creates a remote offer and and applies it as a remote description,
   // creates a local answer and applies is as a local description.
   // Call SendAudioVideoStreamX() before this function
   // to decide which local and remote streams to create.
   void CreateAndSetRemoteOfferAndLocalAnswer() {
     SessionDescriptionInterface* offer = CreateRemoteOffer();
     SetRemoteDescriptionWithoutError(offer);
     SessionDescriptionInterface* answer = CreateAnswer(NULL);
     SetLocalDescriptionWithoutError(answer);
   }
@@ skipping 2860 matching lines @@
   rtc::scoped_ptr<SessionDescriptionInterface> updated_answer2(
       CreateAnswer(NULL));
 
   CompareIceUfragAndPassword(updated_answer2->description(),
                              session_->local_description()->description(),
                              true);
 
   SetLocalDescriptionWithoutError(updated_answer2.release());
 }
 
+// This test verifies that if an offer does an ICE restart on some, but not all
+// media sections, the answer will change the ufrag/password in the correct
+// media sections.
+TEST_F(WebRtcSessionTest, TestCreateAnswerWithNewAndOldUfragAndPassword) {
+  Init();
+  cricket::MediaSessionOptions options;
+  options.recv_video = true;
+  options.recv_audio = true;
+  options.bundle_enabled = false;
+  rtc::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer(options));
+
+  ModifyIceUfragPwd(offer.get(), cricket::MEDIA_TYPE_AUDIO, "aaaa",
+                    "aaaaaaaaaaaaaaaaaaaaaa");
+  ModifyIceUfragPwd(offer.get(), cricket::MEDIA_TYPE_VIDEO, "bbbb",
+                    "bbbbbbbbbbbbbbbbbbbbbb");
+  SetRemoteDescriptionWithoutError(offer.release());
+
+  SendAudioVideoStream1();
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer(nullptr));
+  SetLocalDescriptionWithoutError(answer.release());
+
+  // Receive an offer with new ufrag and password, but only for the video media
+  // section.
+  rtc::scoped_ptr<JsepSessionDescription> updated_offer(
+      CreateRemoteOffer(options, session_->remote_description()));
+  ModifyIceUfragPwd(updated_offer.get(), cricket::MEDIA_TYPE_VIDEO, "cccc",
+                    "cccccccccccccccccccccc");
+  SetRemoteDescriptionWithoutError(updated_offer.release());
+
+  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer(
+      CreateAnswer(nullptr));
+
+  CompareIceUfragAndPassword(updated_answer->description(),
+                             session_->local_description()->description(),
+                             cricket::MEDIA_TYPE_AUDIO, true);
+
+  CompareIceUfragAndPassword(updated_answer->description(),
+                             session_->local_description()->description(),
+                             cricket::MEDIA_TYPE_VIDEO, false);
+
+  SetLocalDescriptionWithoutError(updated_answer.release());
+}
+
 TEST_F(WebRtcSessionTest, TestSessionContentError) {
   Init();
   SendAudioVideoStream1();
   SessionDescriptionInterface* offer = CreateOffer();
   const std::string session_id_orig = offer->session_id();
   const std::string session_version_orig = offer->session_version();
   SetLocalDescriptionWithoutError(offer);
 
   video_channel_ = media_engine_->GetVideoChannel(0);
   video_channel_->set_fail_set_send_codecs(true);
@@ skipping 571 matching lines @@
 }
 
 // TODO(bemasc): Add a TestIceStatesBundle with BUNDLE enabled.  That test
 // currently fails because upon disconnection and reconnection OnIceComplete is
 // called more than once without returning to IceGatheringGathering.
 
 INSTANTIATE_TEST_CASE_P(WebRtcSessionTests,
                         WebRtcSessionTest,
                         testing::Values(ALREADY_GENERATED,
                                         DTLS_IDENTITY_STORE));