Add signaling to support ICE renomination.

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 425 matching lines @@
   if (!rtc::CreateRandomString(kRtcpCnameLength, &cname)) {
     LOG(LS_ERROR) << "Failed to generate CNAME.";
     RTC_DCHECK(false);
   }
   return cname;
 }
 
 bool ExtractMediaSessionOptions(
     const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
     bool is_offer,
+    bool ice_renomination,
     cricket::MediaSessionOptions* session_options) {
   typedef PeerConnectionInterface::RTCOfferAnswerOptions RTCOfferAnswerOptions;
   if (!IsValidOfferToReceiveMedia(rtc_options.offer_to_receive_audio) ||
       !IsValidOfferToReceiveMedia(rtc_options.offer_to_receive_video)) {
     return false;
   }
 
   // If constraints don't prevent us, we always accept video.
   if (rtc_options.offer_to_receive_audio != RTCOfferAnswerOptions::kUndefined) {
     session_options->recv_audio = (rtc_options.offer_to_receive_audio > 0);
   } else {
     session_options->recv_audio = true;
   }
   // For offers, we only offer video if we have it or it's forced by options.
   // For answers, we will always accept video (if offered).
   if (rtc_options.offer_to_receive_video != RTCOfferAnswerOptions::kUndefined) {
     session_options->recv_video = (rtc_options.offer_to_receive_video > 0);
   } else if (is_offer) {
     session_options->recv_video = false;
   } else {
     session_options->recv_video = true;
   }
 
   session_options->vad_enabled = rtc_options.voice_activity_detection;
   session_options->bundle_enabled = rtc_options.use_rtp_mux;
+  // Add transport options so that ice_renomination can be set properly to the
+  // respective transport option.
+  if (session_options->transport_options.empty()) {
+    std::vector<std::string> content_names = {
+        cricket::CN_AUDIO, cricket::CN_VIDEO, cricket::CN_DATA};

[Taylor Brandstetter, 2016/08/17 22:01:59]

This won't work interoperably. The offer could contain any content names;
"CN_AUDIO" etc. are just defaults.

I would recommend setting TransportOptions::ice_renomination where the
TransportOptions are initialized. Meaning in GetOptionsForOffer and
InitializeOptionsForAnswer (you're already doing the latter). There could be a
helper function "MakeTransportOptions" that just does:

TransportOptions options;
options.ice_renomination = ice_renomination_;
return options;

[honghaiz3, 2016/08/19 18:42:00]

I don't think that would work. 
When we initialize an answer, it can extract the content name from the remote
description. But when we initialize an offer, there is no existing local
description or remote one. 
I think "audio", "video", "data" might be default in the standard, but they are
hard-coded in the offer by webrtc and they are unlikely to change. If they will
ever change, the test I wrote should capture it. 
We could make it work with arbitrarily chosen content, but that will need some
convoluted changes. 

[Taylor Brandstetter, 2016/08/20 00:52:13]

Sorry, I just noticed that GetOptionsForOffer *does* add the content names from
the current local description. So there's nothing lacking.

I'd just suggest moving this code into GetOptionsForOffer where the other
TransportOptions are added, since I believe ExtractMediaSessionOptions is meant
as "extract media session options from RTCOfferAnswerOptions."

[honghaiz3, 2016/08/22 18:46:44]

Done.

+    for (auto& content_name : content_names) {
+      session_options->transport_options[content_name] =
+          cricket::TransportOptions();
+    }
+  }
   for (auto& kv : session_options->transport_options) {
     kv.second.ice_restart = rtc_options.ice_restart;
+    kv.second.ice_renomination = ice_renomination;
   }
 
   return true;
 }
 
 bool ParseConstraintsForAnswer(const MediaConstraintsInterface* constraints,
                                cricket::MediaSessionOptions* session_options) {
   bool value = false;
   size_t mandatory_constraints_satisfied = 0;
 
@@ skipping 23 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)) {
-    // kIceRestart defaults to false according to spec.
-    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,
                      std::vector<cricket::RelayServerConfig>* turn_servers) {
   for (const webrtc::PeerConnectionInterface::IceServer& server : servers) {
@@ skipping 88 matching lines @@
 
   session_.reset(new WebRtcSession(
       media_controller_.get(), factory_->network_thread(),
       factory_->worker_thread(), factory_->signaling_thread(),
       port_allocator_.get(),
       std::unique_ptr<cricket::TransportController>(
           factory_->CreateTransportController(port_allocator_.get()))));
 
   stats_.reset(new StatsCollector(this));
 
+  ice_renomination_ = configuration.ice_renomination;
+
   // Initialize the WebRtcSession. It creates transport channels etc.
   if (!session_->Initialize(factory_->options(), std::move(cert_generator),
                             configuration)) {
     return false;
   }
 
   // Register PeerConnection as receiver of local ice candidates.
   // All the callbacks will be posted to the application from PeerConnection.
   session_->RegisterIceObserver(this);
   session_->SignalState.connect(this, &PeerConnection::OnSessionStateChange);
@@ skipping 609 matching lines @@
     if (!network_thread()->Invoke<bool>(
             RTC_FROM_HERE,
             rtc::Bind(&PeerConnection::ReconfigurePortAllocator_n, this,
                       configuration))) {
       return false;
     }
   }
 
   // TODO(deadbeef): Shouldn't have to hop to the worker thread twice...
   session_->SetIceConfig(session_->ParseIceConfig(configuration));
+
+  ice_renomination_ = configuration.ice_renomination;
   return true;
 }
 
 bool PeerConnection::AddIceCandidate(
     const IceCandidateInterface* ice_candidate) {
   TRACE_EVENT0("webrtc", "PeerConnection::AddIceCandidate");
   if (IsClosed()) {
     return false;
   }
   return session_->ProcessIceMessage(ice_candidate);
@@ skipping 332 matching lines @@
     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();
     }
   }

[Taylor Brandstetter, 2016/08/20 00:52:13]

Here's where I think it would make sense to add the default TransportOptions
(for CN_AUDIO, CN_VIDEO) and initialize ice_renomination to the proper value.

-  if (!ExtractMediaSessionOptions(rtc_options, true, session_options)) {
+  if (!ExtractMediaSessionOptions(rtc_options, true, ice_renomination_,
+                                  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) ||
         !remote_audio_tracks_.empty();
@@ skipping 15 matching lines @@
   // people won't try to use them.
   if (HasDataChannels() && session_->data_channel_type() != cricket::DCT_RTP) {
     session_options->data_channel_type = session_->data_channel_type();
   }
 
   session_options->rtcp_cname = rtcp_cname_;
   session_options->crypto_options = factory_->options().crypto_options;
   return true;
 }
 
+void PeerConnection::InitializeOptionsForAnswer(
+    cricket::MediaSessionOptions* session_options) {
+  session_options->recv_audio = false;
+  session_options->recv_video = false;
+  if (session_->remote_description()) {
+    // Initialize the transport_options map.
+    for (const cricket::ContentInfo& content :
+         session_->remote_description()->description()->contents()) {
+      cricket::TransportOptions options;
+      options.ice_renomination = ice_renomination_;
+      session_options->transport_options[content.name] = options;
+    }
+  }
+}
+
 void PeerConnection::FinishOptionsForAnswer(
     cricket::MediaSessionOptions* session_options) {
   // 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();
-    }
-  }
   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());
 
   // RTP data channel is handled in MediaSessionOptions::AddStream. SCTP streams
   // are not signaled in the SDP so does not go through that path and must be
   // handled here.
   // Intentionally unset the data channel type for RTP data channel. Otherwise
   // the RTP data channels would be successfully negotiated by default and the
   // unit tests in WebRtcDataBrowserTest will fail when building with chromium.
   // We want to leave RTP data channels broken, so people won't try to use them.
   if (session_->data_channel_type() != cricket::DCT_RTP) {
     session_options->data_channel_type = session_->data_channel_type();
   }
   session_options->crypto_options = factory_->options().crypto_options;
 }
 
 bool PeerConnection::GetOptionsForAnswer(
     const MediaConstraintsInterface* constraints,
     cricket::MediaSessionOptions* session_options) {
-  session_options->recv_audio = false;
-  session_options->recv_video = false;
+  InitializeOptionsForAnswer(session_options);
   if (!ParseConstraintsForAnswer(constraints, session_options)) {
     return false;
   }
   session_options->rtcp_cname = rtcp_cname_;
 
   FinishOptionsForAnswer(session_options);
   return true;
 }
 
 bool PeerConnection::GetOptionsForAnswer(
     const RTCOfferAnswerOptions& options,
     cricket::MediaSessionOptions* session_options) {
-  session_options->recv_audio = false;
-  session_options->recv_video = false;
-  if (!ExtractMediaSessionOptions(options, false, session_options)) {
+  InitializeOptionsForAnswer(session_options);
+  if (!ExtractMediaSessionOptions(options, false, ice_renomination_,
+                                  session_options)) {
     return false;
   }
   session_options->rtcp_cname = rtcp_cname_;
 
   FinishOptionsForAnswer(session_options);
   return true;
 }
 
 void PeerConnection::RemoveTracks(cricket::MediaType media_type) {
   UpdateLocalTracks(std::vector<cricket::StreamParams>(), media_type);
@@ skipping 610 matching lines @@
 
 bool PeerConnection::StartRtcEventLog_w(rtc::PlatformFile file,
                                         int64_t max_size_bytes) {
   return media_controller_->call_w()->StartEventLog(file, max_size_bytes);
 }
 
 void PeerConnection::StopRtcEventLog_w() {
   media_controller_->call_w()->StopEventLog();
 }
 }  // namespace webrtc