Allow applications to limit the ICE check rate through RTCConfiguration

webrtc/p2p/base/p2ptransportchannel.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 53 matching lines @@
 // When the socket is unwritable, we will use 10 Kbps (ignoring IP+UDP headers)
 // for pinging.  When the socket is writable, we will use only 1 Kbps because
 // we don't want to degrade the quality on a modem.  These numbers should work
 // well on a 28.8K modem, which is the slowest connection on which the voice
 // quality is reasonable at all.
 static const int PING_PACKET_SIZE = 60 * 8;
 
 // The next two ping intervals are at the channel level.
 // STRONG_PING_INTERVAL (480ms) is applied when the selected connection is both
 // writable and receiving.
-static const int STRONG_PING_INTERVAL = 1000 * PING_PACKET_SIZE / 1000;
+const int STRONG_PING_INTERVAL = 1000 * PING_PACKET_SIZE / 1000;
 // WEAK_PING_INTERVAL (48ms) is applied when the selected connection is either
 // not writable or not receiving.
 const int WEAK_PING_INTERVAL = 1000 * PING_PACKET_SIZE / 10000;
 
 // The next two ping intervals are at the connection level.
 // Writable connections are pinged at a faster rate while the connections are
 // stabilizing or the channel is weak.
 const int WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL = 900;  // ms
 // Writable connections are pinged at a slower rate once they are stabilized and
 // the channel is strongly connected.
@@ skipping 338 matching lines @@
     config_.receiving_switching_delay = config.receiving_switching_delay;
     LOG(LS_INFO) << "Set receiving_switching_delay to"
                  << *config_.receiving_switching_delay;
   }
 
   if (config_.default_nomination_mode != config.default_nomination_mode) {
     config_.default_nomination_mode = config.default_nomination_mode;
     LOG(LS_INFO) << "Set default nomination mode to "
                  << static_cast<int>(config_.default_nomination_mode);
   }
+
+  if (config_.min_ping_interval != config.min_ping_interval) {
+    config_.min_ping_interval = config.min_ping_interval;
+    LOG(LS_INFO) << "Set min ping interval to " << *config_.min_ping_interval;
+  }
 }
 
 const IceConfig& P2PTransportChannel::config() const {
   return config_;
 }
 
 void P2PTransportChannel::SetMetricsObserver(
     webrtc::MetricsObserverInterface* observer) {
   metrics_observer_ = observer;
 }
@@ skipping 1072 matching lines @@
   UpdateConnectionStates();
   // When the selected connection is not receiving or not writable, or any
   // active connection has not been pinged enough times, use the weak ping
   // interval.
   bool need_more_pings_at_weak_interval = std::any_of(
       connections_.begin(), connections_.end(), [](Connection* conn) {
         return conn->active() &&
                conn->num_pings_sent() < MIN_PINGS_AT_WEAK_PING_INTERVAL;
       });
   int ping_interval = (weak() || need_more_pings_at_weak_interval)
-                          ? weak_ping_interval_
-                          : STRONG_PING_INTERVAL;
+                          ? weak_ping_interval()
+                          : strong_ping_interval();
   if (rtc::TimeMillis() >= last_ping_sent_ms_ + ping_interval) {
     Connection* conn = FindNextPingableConnection();
     if (conn) {
       PingConnection(conn);
       MarkConnectionPinged(conn);
     }
   }
   int delay = std::min(ping_interval, check_receiving_interval_);
   thread()->PostDelayed(RTC_FROM_HERE, delay, this, MSG_CHECK_AND_PING);
 }
@@ skipping 63 matching lines @@
   int interval = CalculateActiveWritablePingInterval(conn, now);
   return conn->last_ping_sent() + interval <= now;
 }
 
 int P2PTransportChannel::CalculateActiveWritablePingInterval(
     const Connection* conn,
     int64_t now) const {
   // Ping each connection at a higher rate at least
   // MIN_PINGS_AT_WEAK_PING_INTERVAL times.
   if (conn->num_pings_sent() < MIN_PINGS_AT_WEAK_PING_INTERVAL) {
-    return weak_ping_interval_;
+    return weak_ping_interval();
   }
 
   int stable_interval = config_.stable_writable_connection_ping_interval;
   int weak_or_stablizing_interval = std::min(
       stable_interval, WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL);
   // If the channel is weak or the connection is not stable yet, use the
   // weak_or_stablizing_interval.
   return (!weak() && conn->stable(now)) ? stable_interval
                                         : weak_or_stablizing_interval;
 }
@@ skipping 413 matching lines @@
 
 void P2PTransportChannel::set_receiving(bool receiving) {
   if (receiving_ == receiving) {
     return;
   }
   receiving_ = receiving;
   SignalReceivingState(this);
 }
 
 }  // namespace cricket