Add methods to set the ICE connection receiving_timeout values.

webrtc/p2p/base/session.cc

 /*
  *  Copyright 2004 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 326 matching lines @@
       signaling_thread_(signaling_thread),
       worker_thread_(worker_thread),
       port_allocator_(port_allocator),
       sid_(sid),
       content_type_(content_type),
       transport_type_(NS_GINGLE_P2P),
       initiator_(initiator),
       identity_(NULL),
       ssl_max_version_(rtc::SSL_PROTOCOL_DTLS_10),
       ice_tiebreaker_(rtc::CreateRandomId64()),
-      role_switch_(false) {
+      role_switch_(false),
+      ice_receiving_timeout_(-1) {
   ASSERT(signaling_thread->IsCurrent());
 }
 
 BaseSession::~BaseSession() {
   ASSERT(signaling_thread()->IsCurrent());
 
   ASSERT(state_ != STATE_DEINIT);
   LogState(state_, STATE_DEINIT);
   state_ = STATE_DEINIT;
   SignalState(this, state_);
@@ skipping 112 matching lines @@
       if (!iter->second->SetRemoteTransportDescription(tdesc, action,
                                                        error_desc)) {
         return false;
       }
     }
   }
 
   return true;
 }
 
+void BaseSession::SetIceConnectionReceivingTimeout(int timeout_ms) {
+  ice_receiving_timeout_ = timeout_ms;
+  for (const auto& kv : transport_proxies()) {
+    Transport* transport = kv.second->impl();
+    if (transport) {
+      transport->SetChannelReceivingTimeout(timeout_ms);
+    }
+  }
+}
+
 TransportChannel* BaseSession::CreateChannel(const std::string& content_name,
                                              int component) {
   // We create the proxy "on demand" here because we need to support
   // creating channels at any time, even before we send or receive
   // initiate messages, which is before we create the transports.
   TransportProxy* transproxy = GetOrCreateTransportProxy(content_name);
   return transproxy->CreateChannel(component);
 }
 
 TransportChannel* BaseSession::GetChannel(const std::string& content_name,
@@ skipping 69 matching lines @@
 
 void BaseSession::DestroyTransportProxy(
     const std::string& content_name) {
   TransportMap::iterator iter = transports_.find(content_name);
   if (iter != transports_.end()) {
     delete iter->second;
     transports_.erase(content_name);
   }
 }
 
-cricket::Transport* BaseSession::CreateTransport(
-    const std::string& content_name) {
+Transport* BaseSession::CreateTransport(const std::string& content_name) {
   ASSERT(transport_type_ == NS_GINGLE_P2P);
-  return new cricket::DtlsTransport<P2PTransport>(
-      signaling_thread(), worker_thread(), content_name,
-      port_allocator(), identity_);
+  Transport* transport = new DtlsTransport<P2PTransport>(
+      signaling_thread(), worker_thread(), content_name, port_allocator(),
+      identity_);
+  transport->SetChannelReceivingTimeout(ice_receiving_timeout_);
+  return transport;
 }
 
 void BaseSession::SetState(State state) {
   ASSERT(signaling_thread_->IsCurrent());
   if (state != state_) {
     LogState(state_, state);
     state_ = state;
     SignalState(this, state_);
     signaling_thread_->Post(this, MSG_STATE);
   }
@@ skipping 266 matching lines @@
 
     default:
       // Explicitly ignoring some states here.
       break;
     }
     break;
   }
 }
 
 }  // namespace cricket