Adding Obj-C binding for RTCConfiguration::max_ipv6_networks.

webrtc/sdk/objc/Framework/Classes/PeerConnection/RTCConfiguration.mm

 /*
  *  Copyright 2015 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 10 matching lines @@
 
 @implementation RTCConfiguration
 
 @synthesize iceServers = _iceServers;
 @synthesize iceTransportPolicy = _iceTransportPolicy;
 @synthesize bundlePolicy = _bundlePolicy;
 @synthesize rtcpMuxPolicy = _rtcpMuxPolicy;
 @synthesize tcpCandidatePolicy = _tcpCandidatePolicy;
 @synthesize candidateNetworkPolicy = _candidateNetworkPolicy;
 @synthesize continualGatheringPolicy = _continualGatheringPolicy;
+@synthesize maxIPv6Networks = _maxIPv6Networks;
 @synthesize audioJitterBufferMaxPackets = _audioJitterBufferMaxPackets;
 @synthesize audioJitterBufferFastAccelerate = _audioJitterBufferFastAccelerate;
 @synthesize iceConnectionReceivingTimeout = _iceConnectionReceivingTimeout;
 @synthesize iceBackupCandidatePairPingInterval =
     _iceBackupCandidatePairPingInterval;
 @synthesize keyType = _keyType;
 @synthesize iceCandidatePoolSize = _iceCandidatePoolSize;
 @synthesize shouldPruneTurnPorts = _shouldPruneTurnPorts;
 @synthesize shouldPresumeWritableWhenFullyRelayed =
     _shouldPresumeWritableWhenFullyRelayed;
@@ skipping 23 matching lines @@
     _rtcpMuxPolicy =
         [[self class] rtcpMuxPolicyForNativePolicy:config.rtcp_mux_policy];
     _tcpCandidatePolicy = [[self class] tcpCandidatePolicyForNativePolicy:
         config.tcp_candidate_policy];
     _candidateNetworkPolicy = [[self class]
         candidateNetworkPolicyForNativePolicy:config.candidate_network_policy];
     webrtc::PeerConnectionInterface::ContinualGatheringPolicy nativePolicy =
     config.continual_gathering_policy;
     _continualGatheringPolicy =
         [[self class] continualGatheringPolicyForNativePolicy:nativePolicy];
+    _maxIPv6Networks = config.max_ipv6_networks;
     _audioJitterBufferMaxPackets = config.audio_jitter_buffer_max_packets;
     _audioJitterBufferFastAccelerate = config.audio_jitter_buffer_fast_accelerate;
     _iceConnectionReceivingTimeout = config.ice_connection_receiving_timeout;
     _iceBackupCandidatePairPingInterval =
         config.ice_backup_candidate_pair_ping_interval;
     _keyType = RTCEncryptionKeyTypeECDSA;
     _iceCandidatePoolSize = config.ice_candidate_pool_size;
     _shouldPruneTurnPorts = config.prune_turn_ports;
     _shouldPresumeWritableWhenFullyRelayed =
         config.presume_writable_when_fully_relayed;
     if (config.ice_check_min_interval) {
       _iceCheckMinInterval =
           [NSNumber numberWithInt:*config.ice_check_min_interval];
     }
     if (config.ice_regather_interval_range) {
       const rtc::IntervalRange &nativeIntervalRange = config.ice_regather_interval_range.value();
       _iceRegatherIntervalRange =
           [[RTCIntervalRange alloc] initWithNativeIntervalRange:nativeIntervalRange];
     }
   }
   return self;
 }
 
 - (NSString *)description {
-  return [NSString stringWithFormat:
-      @"RTCConfiguration: {\n%@\n%@\n%@\n%@\n%@\n%@\n%@\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%@\n%@\n}\n",
-      _iceServers,
-      [[self class] stringForTransportPolicy:_iceTransportPolicy],
-      [[self class] stringForBundlePolicy:_bundlePolicy],
-      [[self class] stringForRtcpMuxPolicy:_rtcpMuxPolicy],
-      [[self class] stringForTcpCandidatePolicy:_tcpCandidatePolicy],
-      [[self class] stringForCandidateNetworkPolicy:_candidateNetworkPolicy],
-      [[self class]
-          stringForContinualGatheringPolicy:_continualGatheringPolicy],
-      _audioJitterBufferMaxPackets,
-      _audioJitterBufferFastAccelerate,
-      _iceConnectionReceivingTimeout,
-      _iceBackupCandidatePairPingInterval,
-      _iceCandidatePoolSize,
-      _shouldPruneTurnPorts,
-      _shouldPresumeWritableWhenFullyRelayed,
-      _iceCheckMinInterval,
-      _iceRegatherIntervalRange];
+  return
+      [NSString stringWithFormat:
+                    @"RTCConfiguration: "
+                    @"{\n%@\n%@\n%@\n%@\n%@\n%@\n%@\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%@\n%@\n%d\n}\n",
+                    _iceServers,
+                    [[self class] stringForTransportPolicy:_iceTransportPolicy],
+                    [[self class] stringForBundlePolicy:_bundlePolicy],
+                    [[self class] stringForRtcpMuxPolicy:_rtcpMuxPolicy],
+                    [[self class] stringForTcpCandidatePolicy:_tcpCandidatePolicy],
+                    [[self class] stringForCandidateNetworkPolicy:_candidateNetworkPolicy],
+                    [[self class] stringForContinualGatheringPolicy:_continualGatheringPolicy],
+                    _audioJitterBufferMaxPackets,
+                    _audioJitterBufferFastAccelerate,
+                    _iceConnectionReceivingTimeout,
+                    _iceBackupCandidatePairPingInterval,
+                    _iceCandidatePoolSize,
+                    _shouldPruneTurnPorts,
+                    _shouldPresumeWritableWhenFullyRelayed,
+                    _iceCheckMinInterval,
+                    _iceRegatherIntervalRange,
+                    _maxIPv6Networks];
 }
 
 #pragma mark - Private
 
 - (webrtc::PeerConnectionInterface::RTCConfiguration *)
     createNativeConfiguration {
   std::unique_ptr<webrtc::PeerConnectionInterface::RTCConfiguration>
       nativeConfig(new webrtc::PeerConnectionInterface::RTCConfiguration(
           webrtc::PeerConnectionInterface::RTCConfigurationType::kAggressive));
 
   for (RTCIceServer *iceServer in _iceServers) {
     nativeConfig->servers.push_back(iceServer.nativeServer);
   }
   nativeConfig->type =
       [[self class] nativeTransportsTypeForTransportPolicy:_iceTransportPolicy];
   nativeConfig->bundle_policy =
       [[self class] nativeBundlePolicyForPolicy:_bundlePolicy];
   nativeConfig->rtcp_mux_policy =
       [[self class] nativeRtcpMuxPolicyForPolicy:_rtcpMuxPolicy];
   nativeConfig->tcp_candidate_policy =
       [[self class] nativeTcpCandidatePolicyForPolicy:_tcpCandidatePolicy];
   nativeConfig->candidate_network_policy = [[self class]
       nativeCandidateNetworkPolicyForPolicy:_candidateNetworkPolicy];
   nativeConfig->continual_gathering_policy = [[self class]
       nativeContinualGatheringPolicyForPolicy:_continualGatheringPolicy];
+  nativeConfig->max_ipv6_networks = _maxIPv6Networks;
   nativeConfig->audio_jitter_buffer_max_packets = _audioJitterBufferMaxPackets;
   nativeConfig->audio_jitter_buffer_fast_accelerate =
       _audioJitterBufferFastAccelerate  ? true : false;
   nativeConfig->ice_connection_receiving_timeout =
       _iceConnectionReceivingTimeout;
   nativeConfig->ice_backup_candidate_pair_ping_interval =
       _iceBackupCandidatePairPingInterval;
   rtc::KeyType keyType =
       [[self class] nativeEncryptionKeyTypeForKeyType:_keyType];
   // Generate non-default certificate.
@@ skipping 224 matching lines @@
     (RTCEncryptionKeyType)keyType {
   switch (keyType) {
     case RTCEncryptionKeyTypeRSA:
       return rtc::KT_RSA;
     case RTCEncryptionKeyTypeECDSA:
       return rtc::KT_ECDSA;
   }
 }
 
 @end