Cast logging: Additional stats for getStats() API.

media/cast/logging/receiver_time_offset_estimator_impl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
+#include "base/time/tick_clock.h"
 #include "media/cast/logging/receiver_time_offset_estimator_impl.h"
 
 namespace media {
 namespace cast {
 
 // This should be large enough so that we can collect all 3 events before
 // the entry gets removed from the map.
 const size_t kMaxEventTimesMapSize = 100;
 
-ReceiverTimeOffsetEstimatorImpl::ReceiverTimeOffsetEstimatorImpl()
-    : bounded_(false) {}
+ReceiverTimeOffsetEstimatorImpl::ReceiverTimeOffsetEstimatorImpl(
+    base::TickClock* clock)
+    : bounded_(false),
+      clock_(clock),
+      offset_bounds_valid_(false),
+      last_reset_time_(clock_->NowTicks()) {
+}
 
 ReceiverTimeOffsetEstimatorImpl::~ReceiverTimeOffsetEstimatorImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void ReceiverTimeOffsetEstimatorImpl::OnReceiveFrameEvent(
     const FrameEvent& frame_event) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (frame_event.media_type != VIDEO_EVENT)
@@ skipping 56 matching lines @@
   if (event_times_map_.size() > kMaxEventTimesMapSize)
     event_times_map_.erase(event_times_map_.begin());
 }
 
 bool ReceiverTimeOffsetEstimatorImpl::GetReceiverOffsetBounds(
     base::TimeDelta* lower_bound,
     base::TimeDelta* upper_bound) {
   if (!bounded_)
     return false;
 
-  *lower_bound = offset_lower_bound_;
-  *upper_bound = offset_upper_bound_;
+  *lower_bound = prev_offset_lower_bound_;
+  *upper_bound = prev_offset_upper_bound_;
   return true;
 }
 
 void ReceiverTimeOffsetEstimatorImpl::OnReceivePacketEvent(
     const PacketEvent& packet_event) {
   // Not interested in packet events.
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void ReceiverTimeOffsetEstimatorImpl::UpdateOffsetBounds(
     const EventTimes& event) {
   base::TimeDelta lower_bound = event.event_b_time - event.event_c_time;
   base::TimeDelta upper_bound = event.event_b_time - event.event_a_time;
 
-  if (bounded_) {
+  if (offset_bounds_valid_) {
     lower_bound = std::max(lower_bound, offset_lower_bound_);
     upper_bound = std::min(upper_bound, offset_upper_bound_);
   }
 
   if (lower_bound > upper_bound) {
     VLOG(2) << "Got bogus offset bound values [" << lower_bound.InMilliseconds()
             << ", " << upper_bound.InMilliseconds() << "].";
     return;
   }
 
   offset_lower_bound_ = lower_bound;
   offset_upper_bound_ = upper_bound;
+  offset_bounds_valid_ = true;
+  if (!bounded_ ||
+      offset_upper_bound_ - offset_lower_bound_ <
+          base::TimeDelta::FromMilliseconds(20)) {
+    prev_offset_lower_bound_ = offset_lower_bound_;
+    prev_offset_upper_bound_ = offset_upper_bound_;
+  }
+
+  base::TimeTicks now = clock_->NowTicks();
+  if (now - last_reset_time_ > base::TimeDelta::FromSeconds(20)) {
+    last_reset_time_ = now;
+    offset_lower_bound_ = base::TimeDelta();
+    offset_upper_bound_ = base::TimeDelta();
+    offset_bounds_valid_ = false;
+  }
+
   bounded_ = true;
 }
 
 }  // namespace cast
 }  // namespace media