Add a switch to redetermine role when ICE restarts.

webrtc/api/peerconnectioninterface.h

 /*
  *  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 222 matching lines @@
   // organization of the implementation, which isn't stable. So we
   // need getters and setters at least for fields which applications
   // are interested in.
   struct RTCConfiguration {
     // This struct is subject to reorganization, both for naming
     // consistency, and to group settings to match where they are used
     // in the implementation. To do that, we need getter and setter
     // methods for all settings which are of interest to applications,
     // Chrome in particular.
 
+    static RTCConfiguration NativeConfiguration() {

[pthatcher1, 2016/08/30 20:25:36]

Can we call this OptimalConfiguration()?

And have a SafeConfiguration()?

And have comments for each of them describing when one should use one and one
should use the other?

[honghaiz3, 2016/08/30 21:32:59]

Done. Is it better to call it ExperiementalConfiguration, which is more like an
opposite to SafeConfiguration?

+      RTCConfiguration config;
+      config.redetermine_role_on_ice_restart = false;

[pthatcher1, 2016/08/30 20:25:36]

Can you also enable things like max_bundle, required rtcp_mux, and continual
gathering?

[honghaiz3, 2016/08/30 21:32:59]

Will do this in a separate CL as discussed. 

+      return config;
+    }
+
     bool dscp() { return media_config.enable_dscp; }
     void set_dscp(bool enable) { media_config.enable_dscp = enable; }
 
     // TODO(nisse): The corresponding flag in MediaConfig and
     // elsewhere should be renamed enable_cpu_adaptation.
     bool cpu_adaptation() {
       return media_config.video.enable_cpu_overuse_detection;
     }
     void set_cpu_adaptation(bool enable) {
       media_config.video.enable_cpu_overuse_detection = enable;
@@ skipping 45 matching lines @@
     bool enable_rtp_data_channel = false;
     bool enable_quic = false;
     rtc::Optional<int> screencast_min_bitrate;
     rtc::Optional<bool> combined_audio_video_bwe;
     rtc::Optional<bool> enable_dtls_srtp;
     int ice_candidate_pool_size = 0;
     bool prune_turn_ports = false;
     // If set to true, this means the ICE transport should presume TURN-to-TURN
     // candidate pairs will succeed, even before a binding response is received.
     bool presume_writable_when_fully_relayed = false;
+    // If true, ICE role is redetermined when peerconnection sets a local
+    // transport description that indicates an ICE restart.
+    bool redetermine_role_on_ice_restart = true;
   };
 
   struct RTCOfferAnswerOptions {
     static const int kUndefined = -1;
     static const int kMaxOfferToReceiveMedia = 1;
 
     // The default value for constraint offerToReceiveX:true.
     static const int kOfferToReceiveMediaTrue = 1;
 
     int offer_to_receive_video;
@@ skipping 421 matching lines @@
     cricket::WebRtcVideoEncoderFactory* encoder_factory,
     cricket::WebRtcVideoDecoderFactory* decoder_factory) {
   return CreatePeerConnectionFactory(
       worker_and_network_thread, worker_and_network_thread, signaling_thread,
       default_adm, encoder_factory, decoder_factory);
 }
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_API_PEERCONNECTIONINTERFACE_H_