Track pending ICE restarts independently for different media sections.

talk/session/media/mediasession.cc

 /*
  * libjingle
  * Copyright 2004 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 720 matching lines @@
     }
   }
   return false;
 }
 
 template <class C>
 static bool IsRtxCodec(const C& codec) {
   return stricmp(codec.name.c_str(), kRtxCodecName) == 0;
 }
 
+static TransportOptions GetTransportOptions(const MediaSessionOptions& options,
+                                            const std::string& content_name) {
+  auto it = options.transport_options.find(content_name);

[honghaiz3, 2016/02/12 18:21:04]

Perhaps this can be replaced with return options.transport_options[content_name]
and removing this function. 
The downside of [] operation is that it will insert a default value if it is not
found. So it really depends on whether you want to tell the difference between a
default value and "not found".

[Taylor Brandstetter, 2016/02/12 20:43:02]

I can't use the [] operator because the MediaSessionsOptions is const. That's
the main reason why this function is needed.

+  if (it == options.transport_options.end()) {
+    return TransportOptions();
+  }
+  return it->second;
+}
+
 // Create a media content to be offered in a session-initiate,
 // according to the given options.rtcp_mux, options.is_muc,
 // options.streams, codecs, secure_transport, crypto, and streams.  If we don't
 // currently have crypto (in current_cryptos) and it is enabled (in
 // secure_policy), crypto is created (according to crypto_suites).  If
 // add_legacy_stream is true, and current_streams is empty, a legacy
 // stream is created.  The created content is added to the offer.
 template <class C>
 static bool CreateMediaContentOffer(
     const MediaSessionOptions& options,
@@ skipping 845 matching lines @@
     }
   } else {
     if (options.recv_audio) {
       audio->set_direction(MD_RECVONLY);
     } else {
       audio->set_direction(MD_INACTIVE);
     }
   }
 
   desc->AddContent(content_name, NS_JINGLE_RTP, audio.release());
-  if (!AddTransportOffer(content_name, options.audio_transport_options,
+  if (!AddTransportOffer(content_name,
+                         GetTransportOptions(options, content_name),
                          current_description, desc)) {
     return false;
   }
 
   return true;
 }
 
 bool MediaSessionDescriptionFactory::AddVideoContentForOffer(
     const MediaSessionOptions& options,
     const SessionDescription* current_description,
@@ skipping 39 matching lines @@
     }
   } else {
     if (options.recv_video) {
       video->set_direction(MD_RECVONLY);
     } else {
       video->set_direction(MD_INACTIVE);
     }
   }
 
   desc->AddContent(content_name, NS_JINGLE_RTP, video.release());
-  if (!AddTransportOffer(content_name, options.video_transport_options,
+  if (!AddTransportOffer(content_name,
+                         GetTransportOptions(options, content_name),
                          current_description, desc)) {
     return false;
   }
 
   return true;
 }
 
 bool MediaSessionDescriptionFactory::AddDataContentForOffer(
     const MediaSessionOptions& options,
     const SessionDescription* current_description,
@@ skipping 43 matching lines @@
     return false;
   }
 
   if (is_sctp) {
     desc->AddContent(content_name, NS_JINGLE_DRAFT_SCTP, data.release());
   } else {
     data->set_bandwidth(options.data_bandwidth);
     SetMediaProtocol(secure_transport, data.get());
     desc->AddContent(content_name, NS_JINGLE_RTP, data.release());
   }
-  if (!AddTransportOffer(content_name, options.data_transport_options,
+  if (!AddTransportOffer(content_name,
+                         GetTransportOptions(options, content_name),
                          current_description, desc)) {
     return false;
   }
   return true;
 }
 
 bool MediaSessionDescriptionFactory::AddAudioContentForAnswer(
     const SessionDescription* offer,
     const MediaSessionOptions& options,
     const SessionDescription* current_description,
     StreamParamsVec* current_streams,
     SessionDescription* answer) const {
   const ContentInfo* audio_content = GetFirstAudioContent(offer);
 
   scoped_ptr<TransportDescription> audio_transport(CreateTransportAnswer(
-      audio_content->name, offer, options.audio_transport_options,
-      current_description));
+      audio_content->name, offer,
+      GetTransportOptions(options, audio_content->name), current_description));
   if (!audio_transport) {
     return false;
   }
 
   AudioCodecs audio_codecs = audio_codecs_;
   if (!options.vad_enabled) {
     StripCNCodecs(&audio_codecs);
   }
 
   bool bundle_enabled =
@@ skipping 36 matching lines @@
 }
 
 bool MediaSessionDescriptionFactory::AddVideoContentForAnswer(
     const SessionDescription* offer,
     const MediaSessionOptions& options,
     const SessionDescription* current_description,
     StreamParamsVec* current_streams,
     SessionDescription* answer) const {
   const ContentInfo* video_content = GetFirstVideoContent(offer);
   scoped_ptr<TransportDescription> video_transport(CreateTransportAnswer(
-      video_content->name, offer, options.video_transport_options,
-      current_description));
+      video_content->name, offer,
+      GetTransportOptions(options, video_content->name), current_description));
   if (!video_transport) {
     return false;
   }
 
   scoped_ptr<VideoContentDescription> video_answer(
       new VideoContentDescription());
   // Do not require or create SDES cryptos if DTLS is used.
   cricket::SecurePolicy sdes_policy =
       video_transport->secure() ? cricket::SEC_DISABLED : secure();
   bool bundle_enabled =
@@ skipping 33 matching lines @@
 }
 
 bool MediaSessionDescriptionFactory::AddDataContentForAnswer(
     const SessionDescription* offer,
     const MediaSessionOptions& options,
     const SessionDescription* current_description,
     StreamParamsVec* current_streams,
     SessionDescription* answer) const {
   const ContentInfo* data_content = GetFirstDataContent(offer);
   scoped_ptr<TransportDescription> data_transport(CreateTransportAnswer(
-      data_content->name, offer, options.data_transport_options,
-      current_description));
+      data_content->name, offer,
+      GetTransportOptions(options, data_content->name), current_description));
   if (!data_transport) {
     return false;
   }
   bool is_sctp = (options.data_channel_type == DCT_SCTP);
   std::vector<DataCodec> data_codecs(data_codecs_);
   FilterDataCodecs(&data_codecs, is_sctp);
 
   scoped_ptr<DataContentDescription> data_answer(
       new DataContentDescription());
   // Do not require or create SDES cryptos if DTLS is used.
@@ skipping 47 matching lines @@
 }
 
 bool IsVideoContent(const ContentInfo* content) {
   return IsMediaContentOfType(content, MEDIA_TYPE_VIDEO);
 }
 
 bool IsDataContent(const ContentInfo* content) {
   return IsMediaContentOfType(content, MEDIA_TYPE_DATA);
 }
 
-static const ContentInfo* GetFirstMediaContent(const ContentInfos& contents,
-                                               MediaType media_type) {
+const ContentInfo* GetFirstMediaContent(const ContentInfos& contents,
+                                        MediaType media_type) {
   for (ContentInfos::const_iterator content = contents.begin();
        content != contents.end(); content++) {
     if (IsMediaContentOfType(&*content, media_type)) {
       return &*content;
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 const ContentInfo* GetFirstAudioContent(const ContentInfos& contents) {
   return GetFirstMediaContent(contents, MEDIA_TYPE_AUDIO);
 }
 
 const ContentInfo* GetFirstVideoContent(const ContentInfos& contents) {
   return GetFirstMediaContent(contents, MEDIA_TYPE_VIDEO);
 }
 
 const ContentInfo* GetFirstDataContent(const ContentInfos& contents) {
   return GetFirstMediaContent(contents, MEDIA_TYPE_DATA);
 }
 
 static const ContentInfo* GetFirstMediaContent(const SessionDescription* sdesc,
                                                MediaType media_type) {
-  if (sdesc == NULL)
-    return NULL;
+  if (sdesc == nullptr) {
+    return nullptr;
+  }
 
   return GetFirstMediaContent(sdesc->contents(), media_type);
 }
 
 const ContentInfo* GetFirstAudioContent(const SessionDescription* sdesc) {
   return GetFirstMediaContent(sdesc, MEDIA_TYPE_AUDIO);
 }
 
 const ContentInfo* GetFirstVideoContent(const SessionDescription* sdesc) {
   return GetFirstMediaContent(sdesc, MEDIA_TYPE_VIDEO);
@@ skipping 22 matching lines @@
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_VIDEO));
 }
 
 const DataContentDescription* GetFirstDataContentDescription(
     const SessionDescription* sdesc) {
   return static_cast<const DataContentDescription*>(
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_DATA));
 }
 
 }  // namespace cricket