Increase the stun ping interval.

webrtc/p2p/base/port.h

 /*
  *  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 567 matching lines @@
 
   // If |remote_candidate_| is peer reflexive and is equivalent to
   // |new_candidate| except the type, update |remote_candidate_| to
   // |new_candidate|.
   void MaybeUpdatePeerReflexiveCandidate(const Candidate& new_candidate);
 
   // Returns the last received time of any data, stun request, or stun
   // response in milliseconds
   int64_t last_received() const;
 
+  std::vector<SentPing> pings_since_last_response() const {
+    return pings_since_last_response_;
+  }

[pthatcher1, 2016/06/14 00:44:28]

We don't need this if we do the thing below.

+
  protected:
   enum { MSG_DELETE = 0, MSG_FIRST_AVAILABLE };
 
   // Constructs a new connection to the given remote port.
   Connection(Port* port, size_t index, const Candidate& candidate);
 
   // Called back when StunRequestManager has a stun packet to send
   void OnSendStunPacket(const void* data, size_t size, StunRequest* req);
 
   // Callbacks from ConnectionRequest
@@ skipping 22 matching lines @@
   // By default |use_candidate_attr_| flag will be true,
   // as we will be using aggressive nomination.
   // But when peer is ice-lite, this flag "must" be initialized to false and
   // turn on when connection becomes "best connection".
   bool use_candidate_attr_;
   // Whether this connection has been nominated by the controlling side via
   // the use_candidate attribute.
   bool nominated_;
   IceMode remote_ice_mode_;
   StunRequestManager requests_;
   int rtt_;

[pthatcher1, 2016/06/14 00:44:28]

Can we also store this?

int rtt_samples_ = 0;

And then in Connection::OnConnectionRequestResponse do this?

rtt_ = (RTT_RATIO * rtt_ + rtt) / (RTT_RATIO + 1);
rtt_samples_++;


And then:

private:
bool rtt_converged() { return rtt_samples_ > (RTT_RATIO + 1); }

And could we also calculate this?

public:
bool 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);
}

private:
bool missing_responses(int64_t now) {
  if (ping_since_last_response.empty()) {
    return false;
  }

  int64_t waiting = now - ping_since_last_response[0].sent_time;
  return waiting > 2*rtt();
}

   int64_t last_ping_sent_;      // last time we sent a ping to the other side

[pthatcher1, 2016/06/14 00:44:28]

And could we also calculate this?

bool stable() {
  return rtt_converged && !missing_responses();
}

bool missing_responses(int64_t now) {
  if (ping_since_last_response.empty()) {
    return false;
  }

  int64_t waiting = now - ping_since_last_response[0].sent_time;
  return waiting > 2*rtt();
}

   int64_t last_ping_received_;  // last time we received a ping from the other
                                 // side
   int64_t last_data_received_;
   int64_t last_ping_response_received_;
   std::vector<SentPing> pings_since_last_response_;
 
   rtc::RateTracker recv_rate_tracker_;
   rtc::RateTracker send_rate_tracker_;
 
   ConnectionInfo stats_;
@@ skipping 23 matching lines @@
            const rtc::PacketOptions& options) override;
   int GetError() override { return error_; }
 
  private:
   int error_ = 0;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_PORT_H_