Use AggressiveConfiguration as the default configuration in IOS

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 209 matching lines @@
   enum CandidateNetworkPolicy {
     kCandidateNetworkPolicyAll,
     kCandidateNetworkPolicyLowCost
   };
 
   enum ContinualGatheringPolicy {
     GATHER_ONCE,
     GATHER_CONTINUALLY
   };
 
+  enum class RTCConfigurationType {
+    // A configuration that is safer to use, despite it may not have the best

[pthatcher1, 2016/09/01 21:25:49]

despite it may not have => despite it not having

[honghaiz3, 2016/09/01 22:06:29]

Done.

+    // performance. Currently this is the default configuration.
+    kSafe,
+    // An aggressive configuration that has better performance, although it
+    // may be riskier and may need extra support in the application.
+    kAggressive
+  };
+
   // TODO(hbos): Change into class with private data and public getters.
   // TODO(nisse): In particular, accessing fields directly from an
   // application is brittle, since the organization mirrors the
   // 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.
 
-    // A configuration that is safer to use, despite it may not have the best
-    // performance.
-    static RTCConfiguration SafeConfiguration() { return RTCConfiguration(); }
-
-    // An aggressive configuration that has better performance, although it
-    // may be riskier and may need extra support in the application.
-    static RTCConfiguration AggressiveConfiguration() {
-      RTCConfiguration config;
-      config.redetermine_role_on_ice_restart = false;
-      return config;
+    RTCConfiguration() = default;
+    RTCConfiguration(RTCConfigurationType type) {
+      if (type == RTCConfigurationType::kAggressive) {
+        redetermine_role_on_ice_restart = false;
+      }
     }
 
     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;
     }
@@ skipping 489 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_