RTCIceCandidatePairStats.[total/current]RoundTripTime collected.

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 1233 matching lines @@
   state_ = IceCandidatePairState::IN_PROGRESS;
   num_pings_sent_++;
 }
 
 void Connection::ReceivedPing() {
   last_ping_received_ = rtc::TimeMillis();
   UpdateReceiving(last_ping_received_);
 }
 
 void Connection::ReceivedPingResponse(int rtt, const std::string& request_id) {
+  RTC_DCHECK_GE(rtt, 0);
   // 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.
   auto iter = std::find_if(
       pings_since_last_response_.begin(), pings_since_last_response_.end(),
       [request_id](const SentPing& ping) { return ping.id == request_id; });
   if (iter != pings_since_last_response_.end() &&
       iter->nomination > acked_nomination_) {
     acked_nomination_ = iter->nomination;
   }
 
+  current_round_trip_time_ms_ = rtc::Optional<uint32_t>(
+      static_cast<uint32_t>(rtt));
+  if (!total_round_trip_time_ms_) {
+    total_round_trip_time_ms_ = rtc::Optional<uint64_t>(
+        static_cast<uint64_t>(rtt));
+  } else {
+    total_round_trip_time_ms_ = rtc::Optional<uint64_t>(
+        *total_round_trip_time_ms_ + rtt);
+  }
+
   pings_since_last_response_.clear();
   last_ping_response_received_ = rtc::TimeMillis();
   UpdateReceiving(last_ping_response_received_);
   set_write_state(STATE_WRITABLE);
   set_state(IceCandidatePairState::SUCCEEDED);
   if (rtt_samples_ > 0) {
     rtt_ = (RTT_RATIO * rtt_ + rtt) / (RTT_RATIO + 1);
   } else {
     rtt_ = rtt;
   }
@@ skipping 219 matching lines @@
   stats_.receiving = receiving_;
   stats_.writable = write_state_ == STATE_WRITABLE;
   stats_.timeout = write_state_ == STATE_WRITE_TIMEOUT;
   stats_.new_connection = !reported_;
   stats_.rtt = rtt_;
   stats_.local_candidate = local_candidate();
   stats_.remote_candidate = remote_candidate();
   stats_.key = this;
   stats_.state = state_;
   stats_.priority = priority();
+  stats_.total_round_trip_time_ms = total_round_trip_time_ms_;
+  stats_.current_round_trip_time_ms = current_round_trip_time_ms_;
   return stats_;
 }
 
 void Connection::MaybeUpdateLocalCandidate(ConnectionRequest* request,
                                            StunMessage* response) {
   // RFC 5245
   // The agent checks the mapped address from the STUN response.  If the
   // transport address does not match any of the local candidates that the
   // agent knows about, the mapped address represents a new candidate -- a
   // peer reflexive candidate.
@@ skipping 88 matching lines @@
     RTC_DCHECK(sent < 0);
     error_ = port_->GetError();
     stats_.sent_discarded_packets++;
   } else {
     send_rate_tracker_.AddSamples(sent);
   }
   return sent;
 }
 
 }  // namespace cricket