Add methods to set the ICE connection receiving_timeout values.

webrtc/p2p/base/transport.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 103 matching lines @@
                                   const TransportDescription& new_desc) {
   return IceCredentialsChanged(old_desc.ice_ufrag, old_desc.ice_pwd,
                                new_desc.ice_ufrag, new_desc.ice_pwd);
 }
 
 Transport::Transport(rtc::Thread* signaling_thread,
                      rtc::Thread* worker_thread,
                      const std::string& content_name,
                      const std::string& type,
                      PortAllocator* allocator)
-  : signaling_thread_(signaling_thread),
-    worker_thread_(worker_thread),
-    content_name_(content_name),
-    type_(type),
-    allocator_(allocator),
-    destroyed_(false),
-    readable_(TRANSPORT_STATE_NONE),
-    writable_(TRANSPORT_STATE_NONE),
-    receiving_(TRANSPORT_STATE_NONE),
-    was_writable_(false),
-    connect_requested_(false),
-    ice_role_(ICEROLE_UNKNOWN),
-    tiebreaker_(0),
-    protocol_(ICEPROTO_HYBRID),
-    remote_ice_mode_(ICEMODE_FULL) {
+    : signaling_thread_(signaling_thread),
+      worker_thread_(worker_thread),
+      content_name_(content_name),
+      type_(type),
+      allocator_(allocator),
+      destroyed_(false),
+      readable_(TRANSPORT_STATE_NONE),
+      writable_(TRANSPORT_STATE_NONE),
+      receiving_(TRANSPORT_STATE_NONE),
+      was_writable_(false),
+      connect_requested_(false),
+      ice_role_(ICEROLE_UNKNOWN),
+      tiebreaker_(0),
+      protocol_(ICEPROTO_HYBRID),
+      remote_ice_mode_(ICEMODE_FULL),
+      channel_receiving_timeout_(-1) {
 }
 
 Transport::~Transport() {
   ASSERT(signaling_thread_->IsCurrent());
   ASSERT(destroyed_);
 }
 
 void Transport::SetIceRole(IceRole role) {
   worker_thread_->Invoke<void>(Bind(&Transport::SetIceRole_w, this, role));
 }
@@ skipping 18 matching lines @@
 
 bool Transport::GetRemoteCertificate_w(rtc::SSLCertificate** cert) {
   ASSERT(worker_thread()->IsCurrent());
   if (channels_.empty())
     return false;
 
   ChannelMap::iterator iter = channels_.begin();
   return iter->second->GetRemoteCertificate(cert);
 }
 
+void Transport::SetChannelReceivingTimeout(int timeout_ms) {
+  worker_thread_->Invoke<void>(
+      Bind(&Transport::SetChannelReceivingTimeout_w, this, timeout_ms));
+}
+
+void Transport::SetChannelReceivingTimeout_w(int timeout_ms) {
+  ASSERT(worker_thread()->IsCurrent());
+  channel_receiving_timeout_ = timeout_ms;
+  for (const auto& kv : channels_) {
+    kv.second->SetReceivingTimeout(timeout_ms);
+  }
+}
+
 bool Transport::SetLocalTransportDescription(
     const TransportDescription& description,
     ContentAction action,
     std::string* error_desc) {
   return worker_thread_->Invoke<bool>(Bind(
       &Transport::SetLocalTransportDescription_w, this,
       description, action, error_desc));
 }
 
 bool Transport::SetRemoteTransportDescription(
@@ skipping 39 matching lines @@
 
   if (impl_exists) {
     // If this is an existing channel, we should just return it without
     // connecting to all the signal again.
     return impl;
   }
 
   // Push down our transport state to the new channel.
   impl->SetIceRole(ice_role_);
   impl->SetIceTiebreaker(tiebreaker_);
+  impl->SetReceivingTimeout(channel_receiving_timeout_);
   // TODO(ronghuawu): Change CreateChannel_w to be able to return error since
   // below Apply**Description_w calls can fail.
   if (local_description_)
     ApplyLocalTransportDescription_w(impl, NULL);
   if (remote_description_)
     ApplyRemoteTransportDescription_w(impl, NULL);
   if (local_description_ && remote_description_)
     ApplyNegotiatedTransportDescription_w(impl, NULL);
 
   impl->SignalReadableState.connect(this, &Transport::OnChannelReadableState);
@@ skipping 719 matching lines @@
     const TransportDescription* desc) {
   ASSERT(desc != NULL);
   if (desc->transport_type == NS_JINGLE_ICE_UDP) {
     return (desc->HasOption(ICE_OPTION_GICE)) ?
         ICEPROTO_HYBRID : ICEPROTO_RFC5245;
   }
   return ICEPROTO_GOOGLE;
 }
 
 }  // namespace cricket