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 452 matching lines @@
   } 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;
   for (auto& kv : session_options->transport_options) {
     kv.second.ice_restart = rtc_options.ice_restart;
+    kv.second.ice_renomination = rtc_options.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;
   }
 
+  // kIceRestart defaults to false according to spec.
   bool ice_restart = false;
   if (FindConstraint(constraints, MediaConstraintsInterface::kIceRestart,
                      &value, &mandatory_constraints_satisfied)) {
-    // kIceRestart defaults to false according to spec.
-    ice_restart = true;
+    ice_restart = value;

[honghaiz3, 2016/08/11 04:57:58]

This appeared to be wrong before.
Plus this value was never actually used before because transport_options is
empty yet. 

This CL changed the behavior by using this value. 
I think we probably want to remove setting ice_restart here because it is set in
webrtcsession.
WDYT?

[Taylor Brandstetter, 2016/08/11 22:36:50]

You're right; setting the value here (in ParseConstraintsForAnswer) does
nothing, since only the presence of an ICE restart in the offer determines if
there's an ICE restart in the answer. We can remove this.

[honghaiz3, 2016/08/12 18:26:40]

Done.

+  }
+  bool ice_renomination = false;
+  if (FindConstraint(constraints, MediaConstraintsInterface::kIceRenomination,
+                     &value, &mandatory_constraints_satisfied)) {
+    ice_renomination = value;
   }
   for (auto& kv : session_options->transport_options) {
     kv.second.ice_restart = ice_restart;
+    kv.second.ice_renomination = ice_renomination;
   }
 
   if (!constraints) {
     return true;
   }
   return mandatory_constraints_satisfied == constraints->GetMandatory().size();
 }
 
 bool ParseIceServers(const PeerConnectionInterface::IceServers& servers,
                      cricket::ServerAddresses* stun_servers,
@@ skipping 446 matching lines @@
     options.voice_activity_detection = value;
   }
 
   if (FindConstraint(constraints,
                      MediaConstraintsInterface::kIceRestart,
                      &value,
                      &mandatory_constraints)) {
     options.ice_restart = value;
   }
 
+  if (FindConstraint(constraints, MediaConstraintsInterface::kIceRenomination,
+                     &value, &mandatory_constraints)) {
+    options.ice_renomination = value;
+  }
+
   if (FindConstraint(constraints,
                      MediaConstraintsInterface::kUseRtpMux,
                      &value,
                      &mandatory_constraints)) {
     options.use_rtp_mux = value;
   }
 
   CreateOffer(observer, options);
 }
 
@@ skipping 642 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::FinishOptionsForAnswer(
+void PeerConnection::InitializeOptionsForAnswer(
     cricket::MediaSessionOptions* session_options) {
-  // TODO(deadbeef): Once we have transceivers, enumerate them here instead of
-  // ContentInfos.
+  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()) {
       session_options->transport_options[content.name] =
           cricket::TransportOptions();
     }
   }
+}
+
+void PeerConnection::FinishOptionsForAnswer(
+    cricket::MediaSessionOptions* session_options) {
+  // TODO(deadbeef): Once we have transceivers, enumerate them here instead of
+  // ContentInfos.
   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;
+  InitializeOptionsForAnswer(session_options);
   if (!ExtractMediaSessionOptions(options, false, session_options)) {
     return false;
   }
   session_options->rtcp_cname = rtcp_cname_;
 
   FinishOptionsForAnswer(session_options);
   return true;
 }
 
 void PeerConnection::RemoveTracks(cricket::MediaType media_type) {
@@ skipping 611 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