Add signaling to support ICE renomination.

webrtc/api/peerconnection_unittest.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 374 matching lines @@
     offer_answer_options_.ice_restart = true;
     SetExpectIceRestart(true);
   }
 
   void SetExpectIceRestart(bool expect_restart) {
     expect_ice_restart_ = expect_restart;
   }
 
   bool ExpectIceRestart() const { return expect_ice_restart_; }
 
+  void IceRenomination() {
+    offer_answer_constraints_.SetOptionalIceRenomination(true);
+    offer_answer_options_.ice_renomination = true;
+    expect_ice_renomination_ = true;
+  }
+  void SetExpectRemoteIceRenomination(bool expect_renomination) {
+    expect_remote_ice_renomination_ = expect_renomination;
+  }
+  bool ExpectIceRenomination() { return expect_ice_renomination_; }
+  bool ExpectRemoteIceRenomination() { return expect_remote_ice_renomination_; }
+
   void SetReceiveAudioVideo(bool audio, bool video) {
     SetReceiveAudio(audio);
     SetReceiveVideo(video);
     ASSERT_EQ(audio, can_receive_audio());
     ASSERT_EQ(video, can_receive_video());
   }
 
   void SetReceiveAudio(bool audio) {
     if (audio && can_receive_audio())
       return;
@@ skipping 257 matching lines @@
         EXPECT_NE(ufrag_pwd.first, transport_desc->ice_ufrag);
         EXPECT_NE(ufrag_pwd.second, transport_desc->ice_pwd);
       } else {
         const IceUfragPwdPair& ufrag_pwd = ufragpair_it->second;
         EXPECT_EQ(ufrag_pwd.first, transport_desc->ice_ufrag);
         EXPECT_EQ(ufrag_pwd.second, transport_desc->ice_pwd);
       }
     }
   }
 
+  void VerifyLocalIceRenomination() {
+    ASSERT_TRUE(peer_connection_->local_description() != nullptr);
+    const cricket::SessionDescription* desc =
+        peer_connection_->local_description()->description();
+    const cricket::ContentInfos& contents = desc->contents();
+
+    for (auto content : contents) {
+      if (content.rejected)
+        continue;
+      const cricket::TransportDescription* transport_desc =
+          desc->GetTransportDescriptionByName(content.name);
+      const auto& options = transport_desc->transport_options;
+      auto iter = std::find(options.begin(), options.end(),
+                            cricket::ICE_RENOMINATION_STR);
+      EXPECT_EQ(ExpectIceRenomination(), iter != options.end());
+    }
+  }
+
+  void VerifyRemoteIceReomination() {
+    ASSERT_TRUE(peer_connection_->remote_description() != nullptr);
+    const cricket::SessionDescription* desc =
+        peer_connection_->remote_description()->description();
+    const cricket::ContentInfos& contents = desc->contents();
+
+    for (auto content : contents) {
+      if (content.rejected)
+        continue;
+      const cricket::TransportDescription* transport_desc =
+          desc->GetTransportDescriptionByName(content.name);
+      const auto& options = transport_desc->transport_options;
+      auto iter = std::find(options.begin(), options.end(),
+                            cricket::ICE_RENOMINATION_STR);
+      EXPECT_EQ(ExpectRemoteIceRenomination(), iter != options.end());
+    }
+  }
+
   int GetAudioOutputLevelStats(webrtc::MediaStreamTrackInterface* track) {
     rtc::scoped_refptr<MockStatsObserver>
         observer(new rtc::RefCountedObject<MockStatsObserver>());
     EXPECT_TRUE(peer_connection_->GetStats(
         observer, track, PeerConnectionInterface::kStatsOutputLevelStandard));
     EXPECT_TRUE_WAIT(observer->called(), kMaxWaitMs);
     EXPECT_NE(0, observer->timestamp());
     return observer->AudioOutputLevel();
   }
 
@@ skipping 340 matching lines @@
   rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
   rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
       peer_connection_factory_;
 
   bool prefer_constraint_apis_ = true;
   bool auto_add_stream_ = true;
 
   typedef std::pair<std::string, std::string> IceUfragPwdPair;
   std::map<int, IceUfragPwdPair> ice_ufrag_pwd_;
   bool expect_ice_restart_ = false;
+  bool expect_ice_renomination_ = false;
+  bool expect_remote_ice_renomination_ = false;
 
   // Needed to keep track of number of frames sent.
   rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
   // Needed to keep track of number of frames received.
   std::map<std::string, std::unique_ptr<webrtc::FakeVideoTrackRenderer>>
       fake_video_renderers_;
   // Needed to ensure frames aren't received for removed tracks.
   std::vector<std::unique_ptr<webrtc::FakeVideoTrackRenderer>>
       removed_fake_video_renderers_;
   // Needed to keep track of number of frames received when external decoder
@@ skipping 122 matching lines @@
     // Verify size of the local preview.
     EXPECT_EQ(width, initializing_client()->local_rendered_width());
     EXPECT_EQ(height, initializing_client()->local_rendered_height());
   }
 
   void VerifySessionDescriptions() {
     initiating_client_->VerifyRejectedMediaInSessionDescription();
     receiving_client_->VerifyRejectedMediaInSessionDescription();
     initiating_client_->VerifyLocalIceUfragAndPassword();
     receiving_client_->VerifyLocalIceUfragAndPassword();
+
+    initiating_client_->VerifyLocalIceRenomination();
+    receiving_client_->VerifyLocalIceRenomination();
+    initiating_client_->VerifyRemoteIceReomination();
+    receiving_client_->VerifyRemoteIceReomination();
   }
 
   ~P2PTestConductor() {
     if (initiating_client_) {
       initiating_client_->set_signaling_message_receiver(nullptr);
     }
     if (receiving_client_) {
       receiving_client_->set_signaling_message_receiver(nullptr);
     }
   }
@@ skipping 874 matching lines @@
   std::string receiver_candidate_restart;
   EXPECT_TRUE(audio_candidates_reciever_restart->at(0)->ToString(
       &receiver_candidate_restart));
 
   // Verify that the first candidates in the local session descriptions has
   // changed.
   EXPECT_NE(initiator_candidate, initiator_candidate_restart);
   EXPECT_NE(receiver_candidate, receiver_candidate_restart);
 }
 
+TEST_F(P2PTestConductor, IceRenomination) {
+  ASSERT_TRUE(CreateTestClients());
+  // Only one side supports ICE renomination.
+  initializing_client()->SetExpectRemoteIceRenomination(true);
+  receiving_client()->IceRenomination();
+  LocalP2PTest();
+
+  // Both sides support ICE renomination.
+  initializing_client()->SetExpectRemoteIceRenomination(true);
+  receiving_client()->SetExpectRemoteIceRenomination(true);
+  initializing_client()->IceRenomination();
+  receiving_client()->IceRenomination();
+  // Restart ice on the initializing client.
+  receiving_client()->SetExpectIceRestart(true);
+  initializing_client()->IceRestart();
+  // Negotiate and wait for ice completion again and verify ICE renominations.
+  LocalP2PTest();
+}
+
 // This test sets up a call between two parties with audio, and video.
 // It then renegotiates setting the video m-line to "port 0", then later
 // renegotiates again, enabling video.
 TEST_F(P2PTestConductor, LocalP2PTestVideoDisableEnable) {
   ASSERT_TRUE(CreateTestClients());
 
   // Do initial negotiation. Will result in video and audio sendonly m-lines.
   receiving_client()->set_auto_add_stream(false);
   initializing_client()->AddMediaStream(true, true);
   initializing_client()->Negotiate();
@@ skipping 339 matching lines @@
   server.urls.push_back("turn:hostname2");
   servers.push_back(server);
   EXPECT_TRUE(webrtc::ParseIceServers(servers, &stun_servers_, &turn_servers_));
   EXPECT_EQ(2U, turn_servers_.size());
   EXPECT_NE(turn_servers_[0].priority, turn_servers_[1].priority);
 }
 
 #endif // if !defined(THREAD_SANITIZER)
 
 }  // namespace