Track pending ICE restarts independently for different media sections.

webrtc/api/peerconnection.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 426 matching lines @@
   }
 
   if (rtc_options.offer_to_receive_audio != RTCOfferAnswerOptions::kUndefined) {
     session_options->recv_audio = (rtc_options.offer_to_receive_audio > 0);
   }
   if (rtc_options.offer_to_receive_video != RTCOfferAnswerOptions::kUndefined) {
     session_options->recv_video = (rtc_options.offer_to_receive_video > 0);
   }
 
   session_options->vad_enabled = rtc_options.voice_activity_detection;
-  session_options->audio_transport_options.ice_restart =
-      rtc_options.ice_restart;
-  session_options->video_transport_options.ice_restart =
-      rtc_options.ice_restart;
-  session_options->data_transport_options.ice_restart = rtc_options.ice_restart;
   session_options->bundle_enabled = rtc_options.use_rtp_mux;
+  for (auto& kv : session_options->transport_options) {
+    kv.second.ice_restart = rtc_options.ice_restart;
+  }
 
   return true;
 }
 
 bool ParseConstraintsForAnswer(const MediaConstraintsInterface* constraints,
                                cricket::MediaSessionOptions* session_options) {
   bool value = false;
   size_t mandatory_constraints_satisfied = 0;
 
   // kOfferToReceiveAudio defaults to true according to spec.
@@ skipping 22 matching lines @@
   }
 
   if (FindConstraint(constraints, MediaConstraintsInterface::kUseRtpMux, &value,
                      &mandatory_constraints_satisfied)) {
     session_options->bundle_enabled = value;
   } else {
     // kUseRtpMux defaults to true according to spec.
     session_options->bundle_enabled = true;
   }
 
+  bool ice_restart = false;
   if (FindConstraint(constraints, MediaConstraintsInterface::kIceRestart,
                      &value, &mandatory_constraints_satisfied)) {
-    session_options->audio_transport_options.ice_restart = value;
-    session_options->video_transport_options.ice_restart = value;
-    session_options->data_transport_options.ice_restart = value;
-  } else {
     // kIceRestart defaults to false according to spec.
-    session_options->audio_transport_options.ice_restart = false;
-    session_options->video_transport_options.ice_restart = false;
-    session_options->data_transport_options.ice_restart = false;
+    ice_restart = true;
+  }
+  for (auto& kv : session_options->transport_options) {
+    kv.second.ice_restart = ice_restart;
   }
 
   if (!constraints) {
     return true;
   }
   return mandatory_constraints_satisfied == constraints->GetMandatory().size();
 }
 
 bool ParseIceServers(const PeerConnectionInterface::IceServers& servers,
                      cricket::ServerAddresses* stun_servers,
@@ skipping 965 matching lines @@
     CreateSessionDescriptionObserver* observer,
     const std::string& error) {
   CreateSessionDescriptionMsg* msg = new CreateSessionDescriptionMsg(observer);
   msg->error = error;
   signaling_thread()->Post(this, MSG_CREATE_SESSIONDESCRIPTION_FAILED, msg);
 }
 
 bool PeerConnection::GetOptionsForOffer(
     const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
     cricket::MediaSessionOptions* session_options) {
+  // TODO(deadbeef): Once we have transceivers, enumerate them here instead of
+  // ContentInfos.
+  if (session_->local_description()) {
+    for (const cricket::ContentInfo& content :
+         session_->local_description()->description()->contents()) {
+      session_options->transport_options[content.name] =
+          cricket::TransportOptions();
+    }
+  }
   if (!ConvertRtcOptionsForOffer(rtc_options, session_options)) {
     return false;
   }
 
   AddSendStreams(session_options, senders_, rtp_data_channels_);
   // Offer to receive audio/video if the constraint is not set and there are
   // send streams, or we're currently receiving.
   if (rtc_options.offer_to_receive_audio == RTCOfferAnswerOptions::kUndefined) {
     session_options->recv_audio =
         session_options->HasSendMediaStream(cricket::MEDIA_TYPE_AUDIO) ||
@@ skipping 13 matching lines @@
     session_options->data_channel_type = cricket::DCT_SCTP;
   }
   return true;
 }
 
 bool PeerConnection::GetOptionsForAnswer(
     const MediaConstraintsInterface* constraints,
     cricket::MediaSessionOptions* session_options) {
   session_options->recv_audio = false;
   session_options->recv_video = false;
+  // TODO(deadbeef): Once we have transceivers, enumerate them here instead of
+  // ContentInfos.
+  if (session_->remote_description()) {
+    // Initialize the transport_options map.
+    for (const cricket::ContentInfo& content :
+         session_->remote_description()->description()->contents()) {
+      session_options->transport_options[content.name] =
+          cricket::TransportOptions();
+    }
+  }
   if (!ParseConstraintsForAnswer(constraints, session_options)) {
     return false;
   }
 
   AddSendStreams(session_options, senders_, rtp_data_channels_);
   session_options->bundle_enabled =
       session_options->bundle_enabled &&
       (session_options->has_audio() || session_options->has_video() ||
        session_options->has_data());
 
@@ skipping 532 matching lines @@
 DataChannel* PeerConnection::FindDataChannelBySid(int sid) const {
   for (const auto& channel : sctp_data_channels_) {
     if (channel->id() == sid) {
       return channel;
     }
   }
   return nullptr;
 }
 
 }  // namespace webrtc