Set the IceConnectionReceivingTimeout as a RTCConfiguration parameter.

talk/app/webrtc/objc/RTCPeerConnectionInterface.mm

 /*
  * libjingle
  * Copyright 2015 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 20 matching lines @@
 #import "talk/app/webrtc/objc/RTCICEServer+Internal.h"
 
 @implementation RTCConfiguration
 
 @synthesize iceTransportsType = _iceTransportsType;
 @synthesize iceServers = _iceServers;
 @synthesize bundlePolicy = _bundlePolicy;
 @synthesize rtcpMuxPolicy = _rtcpMuxPolicy;
 @synthesize tcpCandidatePolicy = _tcpCandidatePolicy;
 @synthesize audioJitterBufferMaxPackets = _audioJitterBufferMaxPackets;
+@synthesize iceConnectionReceivingTimeout = _iceConnectionReceivingTimeout;
 
 - (instancetype)init {
   if (self = [super init]) {
     // Copy defaults.
     webrtc::PeerConnectionInterface::RTCConfiguration config;
     _iceTransportsType = [RTCEnumConverter iceTransportsTypeForNativeEnum:config.type];
     _bundlePolicy = [RTCEnumConverter bundlePolicyForNativeEnum:config.bundle_policy];
     _rtcpMuxPolicy = [RTCEnumConverter rtcpMuxPolicyForNativeEnum:config.rtcp_mux_policy];
     _tcpCandidatePolicy =
         [RTCEnumConverter tcpCandidatePolicyForNativeEnum:config.tcp_candidate_policy];
     _audioJitterBufferMaxPackets = config.audio_jitter_buffer_max_packets;
+    _iceConnectionReceivingTimeout = config.ice_connection_receiving_timeout;
   }
   return self;
 }
 
 - (instancetype)initWithIceTransportsType:(RTCIceTransportsType)iceTransportsType
                              bundlePolicy:(RTCBundlePolicy)bundlePolicy
                             rtcpMuxPolicy:(RTCRtcpMuxPolicy)rtcpMuxPolicy
                        tcpCandidatePolicy:(RTCTcpCandidatePolicy)tcpCandidatePolicy
-              audioJitterBufferMaxPackets:(int)audioJitterBufferMaxPackets {
+              audioJitterBufferMaxPackets:(int)audioJitterBufferMaxPackets
+            iceConnectionReceivingTimeout:(int)iceConnectionReceivingTimeout {
   if (self = [super init]) {
     _iceTransportsType = iceTransportsType;
     _bundlePolicy = bundlePolicy;
     _rtcpMuxPolicy = rtcpMuxPolicy;
     _tcpCandidatePolicy = tcpCandidatePolicy;
     _audioJitterBufferMaxPackets = audioJitterBufferMaxPackets;
+    _iceConnectionReceivingTimeout = iceConnectionReceivingTimeout;
   }
   return self;
 }
 
 #pragma mark - Private
 
 - (webrtc::PeerConnectionInterface::RTCConfiguration)nativeConfiguration {
   webrtc::PeerConnectionInterface::RTCConfiguration nativeConfig;
   nativeConfig.type = [RTCEnumConverter nativeEnumForIceTransportsType:_iceTransportsType];
   for (RTCICEServer *iceServer : _iceServers) {
     nativeConfig.servers.push_back(iceServer.iceServer);
   }
   nativeConfig.bundle_policy = [RTCEnumConverter nativeEnumForBundlePolicy:_bundlePolicy];
   nativeConfig.rtcp_mux_policy = [RTCEnumConverter nativeEnumForRtcpMuxPolicy:_rtcpMuxPolicy];
   nativeConfig.tcp_candidate_policy =
       [RTCEnumConverter nativeEnumForTcpCandidatePolicy:_tcpCandidatePolicy];
   nativeConfig.audio_jitter_buffer_max_packets = _audioJitterBufferMaxPackets;
+  nativeConfig.ice_connection_receiving_timeout = _iceConnectionReceivingTimeout;
   return nativeConfig;
 }
 
 @end