Add a rate tracker that tracks rate over a given interval split up into buckets that accumulate uni…

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 876 matching lines @@
       connected_(true),
       pruned_(false),
       use_candidate_attr_(false),
       remote_ice_mode_(ICEMODE_FULL),
       requests_(port->thread()),
       rtt_(DEFAULT_RTT),
       last_ping_sent_(0),
       last_ping_received_(0),
       last_data_received_(0),
       last_ping_response_received_(0),
+      recv_rate_tracker_(100u, 10u),
+      send_rate_tracker_(100u, 10u),
       sent_packets_discarded_(0),
       sent_packets_total_(0),
       reported_(false),
       state_(STATE_WAITING) {
   // All of our connections start in WAITING state.
   // TODO(mallinath) - Start connections from STATE_FROZEN.
   // Wire up to send stun packets
   requests_.SignalSendPacket.connect(this, &Connection::OnSendStunPacket);
   LOG_J(LS_INFO, this) << "Connection created";
 }
@@ skipping 91 matching lines @@
   std::string remote_ufrag;
   const rtc::SocketAddress& addr(remote_candidate_.address());
   if (!port_->GetStunMessage(data, size, addr, msg.accept(), &remote_ufrag)) {
     // The packet did not parse as a valid STUN message
 
     // If this connection is readable, then pass along the packet.
     if (read_state_ == STATE_READABLE) {
       // readable means data from this address is acceptable
       // Send it on!
       last_data_received_ = rtc::Time();
-      recv_rate_tracker_.Update(size);
+      recv_rate_tracker_.AddSamples(size);
       SignalReadPacket(this, data, size, packet_time);
 
       // If timed out sending writability checks, start up again
       if (!pruned_ && (write_state_ == STATE_WRITE_TIMEOUT)) {
         LOG(LS_WARNING) << "Received a data packet on a timed-out Connection. "
                         << "Resetting state to STATE_WRITE_INIT.";
         set_write_state(STATE_WRITE_INIT);
       }
     } else {
       // Not readable means the remote address hasn't sent a valid
@@ skipping 424 matching lines @@
   SignalDestroyed(this);
   delete this;
 }
 
 uint32 Connection::last_received() {
   return std::max(last_data_received_,
              std::max(last_ping_received_, last_ping_response_received_));
 }
 
 size_t Connection::recv_bytes_second() {
-  return recv_rate_tracker_.units_second();
+  return recv_rate_tracker_.ComputeRate();
 }
 
 size_t Connection::recv_total_bytes() {
-  return recv_rate_tracker_.total_units();
+  return recv_rate_tracker_.TotalSampleCount();
 }
 
 size_t Connection::sent_bytes_second() {
-  return send_rate_tracker_.units_second();
+  return send_rate_tracker_.ComputeRate();
 }
 
 size_t Connection::sent_total_bytes() {
-  return send_rate_tracker_.total_units();
+  return send_rate_tracker_.TotalSampleCount();
 }
 
 size_t Connection::sent_discarded_packets() {
   return sent_packets_discarded_;
 }
 
 size_t Connection::sent_total_packets() {
   return sent_packets_total_;
 }
 
@@ skipping 74 matching lines @@
     return SOCKET_ERROR;
   }
   sent_packets_total_++;
   int sent = port_->SendTo(data, size, remote_candidate_.address(),
                            options, true);
   if (sent <= 0) {
     ASSERT(sent < 0);
     error_ = port_->GetError();
     sent_packets_discarded_++;
   } else {
-    send_rate_tracker_.Update(sent);
+    send_rate_tracker_.AddSamples(sent);
   }
   return sent;
 }
 
 }  // namespace cricket