Add a continual_gathering_policy in PeerConnection RTCConfiguration

webrtc/p2p/base/transportcontroller.cc

 /*
  *  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 35 matching lines @@
       rtc::Bind(&TransportController::DestroyAllTransports_w, this));
   signaling_thread_->Clear(this);
 }
 
 bool TransportController::SetSslMaxProtocolVersion(
     rtc::SSLProtocolVersion version) {
   return worker_thread_->Invoke<bool>(rtc::Bind(
       &TransportController::SetSslMaxProtocolVersion_w, this, version));
 }
 
-void TransportController::SetIceConnectionReceivingTimeout(int timeout_ms) {
+void TransportController::SetIceConfig(const IceConfig& config) {
   worker_thread_->Invoke<void>(
-      rtc::Bind(&TransportController::SetIceConnectionReceivingTimeout_w, this,
-                timeout_ms));
+      rtc::Bind(&TransportController::SetIceConfig_w, this, config));
 }
 
 void TransportController::SetIceRole(IceRole ice_role) {
   worker_thread_->Invoke<void>(
       rtc::Bind(&TransportController::SetIceRole_w, this, ice_role));
 }
 
 bool TransportController::GetSslRole(rtc::SSLRole* role) {
   return worker_thread_->Invoke<bool>(
       rtc::Bind(&TransportController::GetSslRole_w, this, role));
@@ skipping 158 matching lines @@
 
   Transport* transport = GetTransport_w(transport_name);
   if (transport) {
     return transport;
   }
 
   transport = CreateTransport_w(transport_name);
   // The stuff below happens outside of CreateTransport_w so that unit tests
   // can override CreateTransport_w to return a different type of transport.
   transport->SetSslMaxProtocolVersion(ssl_max_version_);
-  transport->SetChannelReceivingTimeout(ice_receiving_timeout_ms_);
+  transport->SetIceConfig(ice_config_);
   transport->SetIceRole(ice_role_);
   transport->SetIceTiebreaker(ice_tiebreaker_);
   if (certificate_) {
     transport->SetLocalCertificate(certificate_);
   }
   transport->SignalConnecting.connect(
       this, &TransportController::OnTransportConnecting_w);
   transport->SignalWritableState.connect(
       this, &TransportController::OnTransportWritableState_w);
   transport->SignalReceivingState.connect(
@@ skipping 41 matching lines @@
 
   // Max SSL version can only be set before transports are created.
   if (!transports_.empty()) {
     return false;
   }
 
   ssl_max_version_ = version;
   return true;
 }
 
-void TransportController::SetIceConnectionReceivingTimeout_w(int timeout_ms) {
+void TransportController::SetIceConfig_w(const IceConfig& config) {
   RTC_DCHECK(worker_thread_->IsCurrent());
-  ice_receiving_timeout_ms_ = timeout_ms;
+  ice_config_ = config;
   for (const auto& kv : transports_) {
-    kv.second->SetChannelReceivingTimeout(timeout_ms);
+    kv.second->SetIceConfig(ice_config_);
   }
 }
 
 void TransportController::SetIceRole_w(IceRole ice_role) {
   RTC_DCHECK(worker_thread_->IsCurrent());
   ice_role_ = ice_role;
   for (const auto& kv : transports_) {
     kv.second->SetIceRole(ice_role_);
   }
 }
@@ skipping 251 matching lines @@
 bool TransportController::HasChannels_w() {
   for (const auto& kv : transports_) {
     if (kv.second->HasChannels()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace cricket