Use CallStats for RTT in Call, rather than VideoSendStream::GetRtt()

webrtc/video/call_stats.cc

 /*
  *  Copyright (c) 2012 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 16 matching lines @@
 void RemoveOldReports(int64_t now, std::list<CallStats::RttTime>* reports) {
   // A rtt report is considered valid for this long.
   const int64_t kRttTimeoutMs = 1500;
   while (!reports->empty() &&
          (now - reports->front().time) > kRttTimeoutMs) {
     reports->pop_front();
   }
 }
 
 int64_t GetMaxRttMs(std::list<CallStats::RttTime>* reports) {
+  if (reports->empty())
+    return -1;
   int64_t max_rtt_ms = 0;
-  for (std::list<CallStats::RttTime>::const_iterator it = reports->begin();
-       it != reports->end(); ++it) {
-    max_rtt_ms = std::max(it->rtt, max_rtt_ms);
-  }
+  for (const CallStats::RttTime& rtt_time : *reports)
+    max_rtt_ms = std::max(rtt_time.rtt, max_rtt_ms);
   return max_rtt_ms;
 }
 
 int64_t GetAvgRttMs(std::list<CallStats::RttTime>* reports) {
   if (reports->empty()) {
-    return 0;
+    return -1;
   }
   int64_t sum = 0;
   for (std::list<CallStats::RttTime>::const_iterator it = reports->begin();
        it != reports->end(); ++it) {
     sum += it->rtt;
   }
   return sum / reports->size();
 }
 
 void UpdateAvgRttMs(std::list<CallStats::RttTime>* reports, int64_t* avg_rtt) {
-  uint32_t cur_rtt_ms = GetAvgRttMs(reports);
-  if (cur_rtt_ms == 0) {
+  int64_t cur_rtt_ms = GetAvgRttMs(reports);
+  if (cur_rtt_ms == -1) {
     // Reset.
-    *avg_rtt = 0;
+    *avg_rtt = -1;
     return;
   }
-  if (*avg_rtt == 0) {
+  if (*avg_rtt == -1) {
     // Initialize.
     *avg_rtt = cur_rtt_ms;
     return;
   }
   *avg_rtt = *avg_rtt * (1.0f - kWeightFactor) + cur_rtt_ms * kWeightFactor;
 }
 }  // namespace
 
 class RtcpObserver : public RtcpRttStats {
  public:
@@ skipping 12 matching lines @@
  private:
   CallStats* owner_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(RtcpObserver);
 };
 
 CallStats::CallStats(Clock* clock)
     : clock_(clock),
       rtcp_rtt_stats_(new RtcpObserver(this)),
       last_process_time_(clock_->TimeInMilliseconds()),
-      max_rtt_ms_(0),
-      avg_rtt_ms_(0) {}
+      max_rtt_ms_(-1),
+      avg_rtt_ms_(-1) {}
 
 CallStats::~CallStats() {
   assert(observers_.empty());
 }
 
 int64_t CallStats::TimeUntilNextProcess() {
   return last_process_time_ + kUpdateIntervalMs - clock_->TimeInMilliseconds();
 }
 
 int32_t CallStats::Process() {
   rtc::CritScope cs(&crit_);
   int64_t now = clock_->TimeInMilliseconds();
   if (now < last_process_time_ + kUpdateIntervalMs)
     return 0;
 
   last_process_time_ = now;
 
   RemoveOldReports(now, &reports_);
   max_rtt_ms_ = GetMaxRttMs(&reports_);
   UpdateAvgRttMs(&reports_, &avg_rtt_ms_);
 
   // If there is a valid rtt, update all observers with the max rtt.
   // TODO(asapersson): Consider changing this to report the average rtt.

[åsapersson, 2016/02/05 13:50:12]

this todo seems no longer valid, maybe remove

[sprang, 2016/02/05 14:10:22]

Done.

-  if (max_rtt_ms_ > 0) {
+  if (max_rtt_ms_ >= 0) {
     for (std::list<CallStatsObserver*>::iterator it = observers_.begin();
          it != observers_.end(); ++it) {
       (*it)->OnRttUpdate(avg_rtt_ms_, max_rtt_ms_);
     }
   }
   return 0;
 }
 
 int64_t CallStats::avg_rtt_ms() const {
   rtc::CritScope cs(&crit_);
@@ skipping 24 matching lines @@
     }
   }
 }
 
 void CallStats::OnRttUpdate(int64_t rtt) {
   rtc::CritScope cs(&crit_);
   reports_.push_back(RttTime(rtt, clock_->TimeInMilliseconds()));
 }
 
 }  // namespace webrtc