Increase the stun ping interval.

webrtc/p2p/base/port.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 1170 matching lines @@
   requests_.Send(req);
   state_ = STATE_INPROGRESS;
   num_pings_sent_++;
 }
 
 void Connection::ReceivedPing() {
   set_receiving(true);
   last_ping_received_ = rtc::TimeMillis();
 }
 
-void Connection::ReceivedPingResponse() {
+void Connection::ReceivedPingResponse(int rtt) {
   // We've already validated that this is a STUN binding response with
   // the correct local and remote username for this connection.
   // So if we're not already, become writable. We may be bringing a pruned
   // connection back to life, but if we don't really want it, we can always
   // prune it again.
   set_receiving(true);
   set_write_state(STATE_WRITABLE);
   set_state(STATE_SUCCEEDED);
   pings_since_last_response_.clear();
   last_ping_response_received_ = rtc::TimeMillis();
+  rtt_samples_++;
+  rtt_ = (RTT_RATIO * rtt_ + rtt) / (RTT_RATIO + 1);
 }
 
 bool Connection::dead(int64_t now) const {
   if (last_received() > 0) {
     // If it has ever received anything, we keep it alive until it hasn't
     // received anything for DEAD_CONNECTION_RECEIVE_TIMEOUT. This covers the
     // normal case of a successfully used connection that stops working. This
     // also allows a remote peer to continue pinging over a locally inactive
     // (pruned) connection.
     return (now > (last_received() + DEAD_CONNECTION_RECEIVE_TIMEOUT));
   }
 
   if (active()) {
     // If it has never received anything, keep it alive as long as it is
     // actively pinging and not pruned. Otherwise, the connection might be
     // deleted before it has a chance to ping. This is the normal case for a
     // new connection that is pinging but hasn't received anything yet.
     return false;
   }
 
   // If it has never received anything and is not actively pinging (pruned), we
   // keep it around for at least MIN_CONNECTION_LIFETIME to prevent connections
   // from being pruned too quickly during a network change event when two
   // networks would be up simultaneously but only for a brief period.
   return now > (time_created_ms_ + MIN_CONNECTION_LIFETIME);
 }
 
+bool Connection::stable(int64_t now) {
+  // A connection is stable if it's RTT has converged and it isn't missing any
+  // responses.  We should send pings at a higher rate until the RTT converges
+  // and whenever a ping response is missing (so that we can detect
+  // unwritability faster)
+  return rtt_converged() && !missing_responses(now);
+}
+
 std::string Connection::ToDebugId() const {
   std::stringstream ss;
   ss << std::hex << this;
   return ss.str();
 }
 
 uint32_t Connection::ComputeNetworkCost() const {
   // TODO(honghaiz): Will add rtt as part of the network cost.
   return port()->network_cost() + remote_candidate_.network_cost();
 }
@@ skipping 50 matching lines @@
 }
 
 void Connection::OnConnectionRequestResponse(ConnectionRequest* request,
                                              StunMessage* response) {
   // Log at LS_INFO if we receive a ping response on an unwritable
   // connection.
   rtc::LoggingSeverity sev = !writable() ? rtc::LS_INFO : rtc::LS_VERBOSE;
 
   int rtt = request->Elapsed();
 
-  ReceivedPingResponse();
+  ReceivedPingResponse(rtt);
 
   if (LOG_CHECK_LEVEL_V(sev)) {
     bool use_candidate = (
         response->GetByteString(STUN_ATTR_USE_CANDIDATE) != nullptr);
     std::string pings;
     PrintPingsSinceLastResponse(&pings, 5);
     LOG_JV(sev, this) << "Received STUN ping response"
                       << ", id=" << rtc::hex_encode(request->id())
                       << ", code=0"  // Makes logging easier to parse.
                       << ", rtt=" << rtt
                       << ", use_candidate=" << use_candidate
                       << ", pings_since_last_response=" << pings;
   }
 
-  rtt_ = (RTT_RATIO * rtt_ + rtt) / (RTT_RATIO + 1);
   stats_.recv_ping_responses++;
 
   MaybeAddPrflxCandidate(request, response);
 }
 
 void Connection::OnConnectionRequestErrorResponse(ConnectionRequest* request,
                                                   StunMessage* response) {
   const StunErrorCodeAttribute* error_attr = response->GetErrorCode();
   int error_code = STUN_ERROR_GLOBAL_FAILURE;
   if (error_attr) {
@@ skipping 158 matching lines @@
   new_local_candidate.set_network_cost(local_candidate().network_cost());
 
   // Change the local candidate of this Connection to the new prflx candidate.
   local_candidate_index_ = port_->AddPrflxCandidate(new_local_candidate);
 
   // SignalStateChange to force a re-sort in P2PTransportChannel as this
   // Connection's local candidate has changed.
   SignalStateChange(this);
 }
 
+bool Connection::rtt_converged() {
+  return rtt_samples_ > (RTT_RATIO + 1);
+}
+
+bool Connection::missing_responses(int64_t now) {
+  if (pings_since_last_response_.empty()) {
+    return false;
+  }
+
+  int64_t waiting = now - pings_since_last_response_[0].sent_time;
+  return waiting > 2 * rtt();
+}
+
 ProxyConnection::ProxyConnection(Port* port,
                                  size_t index,
                                  const Candidate& remote_candidate)
     : Connection(port, index, remote_candidate) {}
 
 int ProxyConnection::Send(const void* data, size_t size,
                           const rtc::PacketOptions& options) {
   if (write_state_ == STATE_WRITE_INIT || write_state_ == STATE_WRITE_TIMEOUT) {
     error_ = EWOULDBLOCK;
     return SOCKET_ERROR;
   }
   stats_.sent_total_packets++;
   int sent = port_->SendTo(data, size, remote_candidate_.address(),
                            options, true);
   if (sent <= 0) {
     ASSERT(sent < 0);
     error_ = port_->GetError();
     stats_.sent_discarded_packets++;
   } else {
     send_rate_tracker_.AddSamples(sent);
   }
   return sent;
 }
 
 }  // namespace cricket